atris 3.82.3 → 3.82.4

package/README.md

@@ -28,7 +28,7 @@ Mem0, Zep and Letta remember the users of a chat app. Atris remembers the projec
 npx -y atris aeo scan yoursite.com --vs competitor.com
 ```
 
-You get a score out of 100, each gap with its fix, a side-by-side score against a competitor, and a draft `llms.txt` you can publish. To see what ChatGPT actually says when buyers ask about your business, run the free check at https://atris.ai/aeo/check.
+You get a score out of 100, each gap with its fix, a side-by-side score against a competitor, and a draft `llms.txt` you can publish. To see what ChatGPT actually says when buyers ask about your business, run the free check at https://atris.ai/aeo/check. Guide to both checks and the tools that run them: [docs/answer-engine-checks.md](docs/answer-engine-checks.md).
 
 ## Quick Start
 

package/atris/atris.md

@@ -149,6 +149,12 @@ The Mission anchors, goals point, a mission run commits, tasks prove, accepts la
 
 ## task source of truth
 
+For the next agent step, use `atris next --agent <functional-member> --json`.
+Known worker shells choose this view automatically; `--human` shows the
+person's view without changing acceptance permission. An unchecked task
+requires a goal, exit, first move and runnable check through `atris task plan`.
+The recommendation itself never claims, executes, accepts or awards XP.
+
 Use `atris task` as the source of truth for active work. It stores durable local
 SQLite state plus append-only task events, and refreshes
 `.atris/state/tasks.projection.json` for desktop/web UIs. `atris/TODO.md` is a

package/bin/atris.js

@@ -633,6 +633,7 @@ function showHelpAll() {
   console.log('  verify     - Validate work is done (tests, MAP.md, changes)');
   console.log('  slop       - Deterministic slop detector: frontend/prose tells, dead code (slop dead --exports)');
   console.log('  sentinel   - Security audit: engines hunt for holes, a different model verifies each one');
+  console.log('               free checks: sentinel agents, sentinel watch, sentinel guard install');
   console.log('  voice      - Scan binary voice tells or judge reply shape and plainness');
   console.log('  recover    - Explain stopped missions; --apply performs safe recovery only');
   console.log('  task       - Local agent task plane (atomic claims, TODO import)');

package/commands/aeo.js

@@ -217,10 +217,23 @@ async function aeoScan(args) {
     console.log('\n  Gaps:');
     for (const g of gaps) console.log(`   ✗ ${g.title || g.key}: ${g.fix || ''}`);
   }
+  // What an agent actually gets from live requests: plain text on request,
+  // crawler access, words without scripts, structured data, sitemap.
+  const access = data.agent_access;
+  if (access && Array.isArray(access.checks)) {
+    console.log(`\n  Agent access: ${access.score}/${access.max_score ?? 100}`);
+    for (const c of access.checks) {
+      console.log(`   ${c.passed ? '✓' : '✗'} ${c.title}${c.passed ? '' : `: ${c.fix || c.detail || ''}`}`);
+    }
+  }
   const comp = data.competitors || [];
   if (comp.length) {
-    console.log('\n  Head-to-head:');
-    for (const c of comp) console.log(`   ${pad(String(c.score ?? '?'), 4)} ${c.url || c.name}`);
+    const withAccess = comp.some((c) => c.agent_access_score != null);
+    console.log(withAccess ? '\n  Head-to-head (score, agent access):' : '\n  Head-to-head:');
+    for (const c of comp) {
+      const extra = withAccess ? `${pad(String(c.agent_access_score ?? '?'), 4)} ` : '';
+      console.log(`   ${pad(String(c.score ?? '?'), 4)} ${extra}${c.url || c.name}`);
+    }
   }
   if (data.draft_llms_txt) {
     console.log('\n  Draft llms.txt included, save it with:');

package/commands/next.js

@@ -19,7 +19,7 @@ const {
 } = require('../lib/next-moves');
 
 function showHelp(log = console.log) {
-  log('Usage: atris next [--json]');
+  log('Usage: atris next [--agent <member>|--human] [--json]');
   return 0;
 }
 
@@ -179,12 +179,17 @@ function executeCard(card, root, log = console.log) {
 
 function actionToken(args = []) {
   const list = Array.isArray(args) ? args : [];
-  const token = list.find((arg) => {
+  for (let i = 0; i < list.length; i += 1) {
+    const arg = list[i];
     const text = String(arg || '').trim();
-    if (!text || text.startsWith('-')) return false;
-    return true;
-  });
-  return String(token || '').trim().toLowerCase();
+    if (['--agent', '--as', '--task', '--goal-id', '--goal_id', '--tag', '--status', '--review-state', '--review_state'].includes(text)) {
+      if (list[i + 1] && !String(list[i + 1]).startsWith('-')) i += 1;
+      continue;
+    }
+    if (!text || text.startsWith('-')) continue;
+    return text.toLowerCase();
+  }
+  return '';
 }
 
 function nextCommand(args = [], root = process.cwd(), { log = console.log } = {}) {
@@ -193,6 +198,11 @@ function nextCommand(args = [], root = process.cwd(), { log = console.log } = {}
 
   const asJson = wantsJson(list);
   const action = actionToken(list);
+  if (!['skip', 'no', 'yes'].includes(action)) {
+    const { buildAgentNext, printAgentNext } = require('../lib/agent-next');
+    const agent = buildAgentNext({ root, args: list });
+    if (agent) return printAgentNext(agent, { asJson, log });
+  }
 
   if (!action || action === 'json') return speakNext(root, { asJson, log });
 

package/commands/now.js

@@ -612,7 +612,7 @@ function nowJsonPayload(root = process.cwd()) {
 function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const help = args.includes('--help') || args.includes('-h') || args[0] === 'help';
   if (help) {
-    console.log('Usage: atris now [--init|--refresh|--all|--path] [--json]');
+    console.log('Usage: atris now [--init|--refresh|--all|--path] [--agent <member>|--human] [--json]');
     console.log('');
     console.log('Show the current operating truth for this workspace.');
     console.log('');
@@ -632,6 +632,11 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const asJson = args.includes('--json');
 
   try {
+    if (!init && !refresh && !all && !pathOnly) {
+      const { buildAgentNext, printAgentNext } = require('../lib/agent-next');
+      const agent = buildAgentNext({ root, args });
+      if (agent) return printAgentNext(agent, { asJson, alias: 'next' });
+    }
     if (asJson && !init && !refresh && !all && !pathOnly) {
       const payload = nowJsonPayload(root);
       printNowJson(payload);

package/commands/security-review.js

@@ -590,6 +590,7 @@ async function auditScheduleCommand(argv, deps) {
   if (!installed.ok) { cloud.removeApproval(target, deps.homeDir); console.error(`  could not install the timer: ${installed.error}`); return 1; }
   console.log(`  scheduled reviews are on for ${tildePath(target)}, once a ${every}`);
   console.log('  each run uses the quick profile and saves its summary to your atris account');
+  console.log('  each run also checks your agent setup and dependencies for free');
   if (approval.engine === 'local') console.log('  runs use only codex and claude on this machine. they never switch to atris models');
   else console.log(`  runs use atris models and stop at ${approval.max_credits} credits`);
   console.log(`  log: ${tildePath(plan.log_path)}`);
@@ -608,6 +609,11 @@ async function auditCommand(argv, deps = {}) {
     console.log(renderAuditLanding({ dir: last.dir, meta: last.meta, records: last.records }));
     return 0;
   }
+  if (['agents', 'guard', 'watch', 'flush'].includes(argv[0])) {
+    const powers = require('./sentinel-powers');
+    const run = { agents: powers.agentsCommand, guard: powers.guardCommand, watch: powers.watchCommand, flush: powers.flushCommand }[argv[0]];
+    return run(argv.slice(1), deps);
+  }
   if (argv[0] === 'upload') return auditUploadCommand(argv.slice(1), deps);
   if (argv[0] === 'schedule') return auditScheduleCommand(argv.slice(1), deps);
   let opts;
@@ -618,6 +624,11 @@ async function auditCommand(argv, deps = {}) {
   if (opts.scheduled) {
     const approval = cloud.readApproval(root, deps.homeDir);
     if (!approval) { console.error('security-review audit: this folder has no approved schedule. nothing ran. run atris sentinel schedule again'); return 2; }
+    // The free checks run first, so a review that stops at its credit limit
+    // still leaves today's agent and dependency results.
+    try {
+      await require('./sentinel-powers').runScheduledFreeChecks(root, { ...deps, upload: opts.upload, log: opts.json ? (m) => console.error(m) : (m) => console.log(m) });
+    } catch (e) { console.error(`  warning: the free checks did not finish: ${e.message}`); }
     opts.hunter = null;
     opts.verifier = null;
     opts.engine = approval.engine;
@@ -706,6 +717,18 @@ function printAuditHelp() {
   only the summary is saved: plain sentences, file:line locations and counts.
   source code and code lines never leave in an upload.
 
+  free checks, no model and no credits:
+
+    atris sentinel agents [path]                check agent instructions, settings, hooks, mcp and skills
+    atris sentinel agents --home                also check ~/.claude and ~/.codex
+    atris sentinel watch [path]                 known attacks in your dependencies (osv database)
+    atris sentinel watch --fix                  update affected packages on a new branch, never pushed
+    atris sentinel guard install [--global]     stop risky agent commands before they run
+    atris sentinel guard test                   see which sample commands the guard stops
+
+  results go to your atris dashboard when you are logged in. add --no-upload
+  to keep them on this machine. secret values and file contents never leave.
+
   reviews on a timer:
 
     atris sentinel schedule --every day [path]  quick review once a day, saved to your account
@@ -714,6 +737,7 @@ function printAuditHelp() {
                                                 timed runs on atris models, at most 20 credits each
     atris sentinel schedule --uninstall [path]  stop the timer
 
+  every timed run also runs the free agents and watch checks.
   the engine is picked when the timer goes on. on atris models you see the
   price and say yes then. a timed run never switches to atris models later.
 

package/commands/sentinel-powers.js

@@ -0,0 +1,284 @@
+'use strict';
+
+// The free sentinel commands: agents, guard, watch and flush. Each reports
+// to the dashboard through POST /api/sentinel/events (lib/sentinel-events.js).
+//
+//   atris sentinel agents [path] [--home]        check an agent setup
+//   atris sentinel guard install|uninstall|status|test [--global]
+//   atris sentinel watch [path] [--fix]          known attacks in dependencies
+//   atris sentinel flush                         send queued guard events
+//
+// An upload problem is a warning line. It never changes the exit code.
+
+const fs = require('fs');
+const path = require('path');
+
+function tildePath(p, home = require('os').homedir()) {
+  return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+}
+
+function parseFlags(argv, known) {
+  const opts = { paths: [] };
+  for (const a of argv) {
+    if (a.startsWith('--')) {
+      const name = a.slice(2);
+      if (!known.includes(name)) throw new Error(`unknown flag: ${a}`);
+      opts[name.replace(/-([a-z])/g, (_, c) => c.toUpperCase())] = true;
+    } else if (a.startsWith('-') && a !== '-') {
+      throw new Error(`unknown flag: ${a}`);
+    } else opts.paths.push(a);
+  }
+  return opts;
+}
+
+function resolveRoot(opts, deps) {
+  const root = path.resolve(opts.paths[0] || deps.root || process.cwd());
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) throw new Error(`${root} is not a folder`);
+  return root;
+}
+
+function tokenFor(deps) {
+  if (deps.token !== undefined) return deps.token;
+  return require('../lib/sentinel-cloud').authToken();
+}
+
+function uploadLine(res, what) {
+  if (res.skipped === 'no-upload') return '  kept on this machine. nothing was sent (--no-upload)';
+  if (res.skipped === 'not-logged-in') return '  not logged in. nothing was sent. run atris login to see this on your dashboard';
+  if (!res.ok) return `  warning: could not send ${what} to your atris dashboard: ${res.reason}. the check itself is done`;
+  const resolved = res.resolved ? ` and marked ${res.resolved} as fixed` : '';
+  return `  sent ${res.sent - (res.resolved || 0)} ${what} to your atris dashboard${resolved}. no file contents or secret values were sent`;
+}
+
+// ---------------------------------------------------------------- agents
+
+async function runAgents(root, { home = false, upload = true, deps = {} } = {}) {
+  const agents = require('../lib/sentinel-agents');
+  const events = require('../lib/sentinel-events');
+  const homeDir = deps.homeDir || process.env.HOME || require('os').homedir();
+  const result = agents.runAgentCheck(root, { home, homeDir });
+  const evs = agents.toEvents(result, { repo: deps.repo });
+  let res;
+  try {
+    res = await events.reportFindings(root, 'agent_check', evs, { token: upload ? tokenFor(deps) : '', base: deps.base, env: deps.env || process.env, upload });
+  } catch (e) { res = { ok: false, reason: e.message }; }
+  return { result, events: evs, upload: res };
+}
+
+async function agentsCommand(argv, deps = {}) {
+  let opts;
+  try { opts = parseFlags(argv, ['home', 'json', 'no-upload']); } catch (e) { console.error(`  ${e.message}`); return 2; }
+  let root;
+  try { root = resolveRoot(opts, deps); } catch (e) { console.error(`  ${e.message}`); return 2; }
+  const { result, upload } = await runAgents(root, { home: Boolean(opts.home), upload: !opts.noUpload, deps });
+  if (opts.json) {
+    console.log(JSON.stringify({ ok: result.grade !== 'fail', grade: result.grade, areas: result.areas, files: result.files, findings: result.findings, upload }, null, 2));
+  } else {
+    console.log(require('../lib/sentinel-agents').renderReport(result));
+    console.log(uploadLine(upload, 'the findings'));
+    console.log('');
+  }
+  return result.grade === 'fail' ? 1 : 0;
+}
+
+// ---------------------------------------------------------------- watch
+
+async function runWatchCheck(root, { upload = true, deps = {} } = {}) {
+  const watch = require('../lib/sentinel-watch');
+  const events = require('../lib/sentinel-events');
+  const result = await watch.runWatch(root, { base: deps.osvBase || process.env.ATRIS_OSV_BASE || watch.OSV_BASE, ...(deps.request ? { request: deps.request } : {}) });
+  const evs = watch.toEvents(result, { repo: deps.repo });
+  let res;
+  if (result.offline) res = { ok: true, skipped: 'offline', sent: 0 };
+  else {
+    try {
+      res = await events.reportFindings(root, 'threat', evs, { token: upload ? tokenFor(deps) : '', base: deps.base, env: deps.env || process.env, upload });
+    } catch (e) { res = { ok: false, reason: e.message }; }
+  }
+  return { result, events: evs, upload: res };
+}
+
+async function watchCommand(argv, deps = {}) {
+  let opts;
+  try { opts = parseFlags(argv, ['fix', 'json', 'no-upload']); } catch (e) { console.error(`  ${e.message}`); return 2; }
+  let root;
+  try { root = resolveRoot(opts, deps); } catch (e) { console.error(`  ${e.message}`); return 2; }
+  const watch = require('../lib/sentinel-watch');
+  const { result, upload } = await runWatchCheck(root, { upload: !opts.noUpload, deps });
+  let fix = null;
+  if (opts.fix && !result.offline && result.affected.length) {
+    try { fix = watch.applyFix(root, result, { log: (m) => console.error(`  ${m}`) }); } catch (e) { fix = { ok: false, reason: String(e.message || e).split('\n')[0] }; }
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ ok: !result.affected.some((a) => a.severity === 'critical' || a.severity === 'high'), ...result, upload, fix }, null, 2));
+  } else {
+    console.log(watch.renderReport(result));
+    if (upload.skipped !== 'offline') console.log(uploadLine(upload, 'the threats'));
+    if (fix) {
+      console.log('');
+      if (!fix.ok) console.log(`  the fix did not run: ${fix.reason}`);
+      else if (!fix.branch) console.log(`  the fix changed nothing${fix.message ? `: ${fix.message}` : ''}`);
+      else {
+        console.log(`  updated ${fix.changed} file${fix.changed === 1 ? '' : 's'} on a new branch: ${fix.branch}`);
+        console.log(`  review it with: git diff ${fix.from || 'main'}...${fix.branch}`);
+        console.log(`  go back with: git checkout ${fix.from || 'main'}`);
+        console.log('  nothing was pushed');
+      }
+      if (fix.manual && fix.manual.length) {
+        console.log(`  update these yourself: ${fix.manual.map((a) => `${a.name} to ${a.fixed}`).join(', ')}`);
+      }
+    }
+    console.log('');
+  }
+  if (fix && !fix.ok) return 1;
+  return result.affected.some((a) => a.severity === 'critical' || a.severity === 'high') ? 1 : 0;
+}
+
+// ---------------------------------------------------------------- guard
+
+function guardHelp() {
+  console.log(`
+  atris sentinel guard, an action guard for coding agents
+
+    atris sentinel guard install            guard claude code in this project
+    atris sentinel guard install --global   guard every claude code session on this computer
+    atris sentinel guard status [--global]  is it on and what it stopped today
+    atris sentinel guard test               run sample commands through the rules
+    atris sentinel guard uninstall [--global]
+
+  it stops shell commands that send secrets out, delete home or root, force
+  push to main, drop databases or turn off security. normal curl, git push
+  and rm in project folders still run. it uses fixed rules and no model.
+  trusted sites for secrets can be added in ~/.atris/sentinel/guard.json.
+
+  what it promises: it stops the common ways an agent leaks a key or runs a
+  destructive command. a network call that carries a secret runs only through
+  curl, wget or httpie with options on a short safe list, to trusted sites. a
+  command that names claude settings or the guard's files runs only when it
+  is a read-only program like cat, grep or git log. what it cannot promise: a program that hides its
+  intent can still get past fixed rules. it does not read encoded payloads
+  or scripts written to disk and then run. it does not read interpreters
+  like python -c either. it is a seatbelt, not a sandbox.
+`);
+  return 0;
+}
+
+async function guardCommand(argv, deps = {}) {
+  const sub = argv[0] || 'status';
+  const rest = argv.slice(1);
+  if (sub === 'help' || argv.includes('--help') || argv.includes('-h')) return guardHelp();
+  let opts;
+  try { opts = parseFlags(rest, ['global', 'json']); } catch (e) { console.error(`  ${e.message}`); return 2; }
+  const inst = require('../lib/sentinel-guard-install');
+  const env = deps.env || process.env;
+  const root = deps.root || process.cwd();
+  const where = opts.global ? 'every claude code session on this computer' : `claude code in ${tildePath(path.resolve(root), env.HOME || undefined)}`;
+  if (sub === 'install') {
+    let st;
+    try { st = inst.install({ global: Boolean(opts.global), root, env, atrisBin: deps.atrisBin }); } catch (e) { console.error(`  could not install the guard: ${e.message}. your settings were not changed`); return 1; }
+    console.log(`\n  the sentinel guard is on for ${where}`);
+    console.log(`  settings: ${tildePath(st.settings, env.HOME || undefined)}`);
+    console.log('  it checks each shell command and file edit before it runs. try it with atris sentinel guard test');
+    if (st.hooks_off) console.log('  warning: these settings turn all hooks off. the guard will not run until that is removed');
+    console.log('  it starts with the next claude code session\n');
+    return 0;
+  }
+  if (sub === 'uninstall') {
+    try { inst.uninstall({ global: Boolean(opts.global), root, env }); } catch (e) { console.error(`  could not remove the guard: ${e.message}. your settings were not changed`); return 1; }
+    console.log(`  the sentinel guard is off for ${where}`);
+    return 0;
+  }
+  if (sub === 'status') {
+    const st = inst.status({ global: Boolean(opts.global), root, env });
+    const blocks = inst.recentBlocks({ env });
+    const events = require('../lib/sentinel-events');
+    const waiting = events.queueSize(env);
+    if (opts.json) { console.log(JSON.stringify({ ...st, blocked_today: blocks.length, waiting_to_send: waiting }, null, 2)); return 0; }
+    console.log('');
+    if (st.installed) console.log(`  the sentinel guard is on for ${where}`);
+    else if (!st.readable) console.log(`  could not read ${tildePath(st.settings, env.HOME || undefined)}. the guard state is unknown`);
+    else console.log(`  the sentinel guard is off for ${where}. turn it on with atris sentinel guard install${opts.global ? ' --global' : ''}`);
+    if (st.installed && !st.current) console.log('  the installed copy is older than this atris. run install again to update it');
+    if (st.hooks_off) console.log('  warning: these settings turn all hooks off. the guard does not run');
+    console.log(`  stopped ${blocks.length} action${blocks.length === 1 ? '' : 's'} in the last day${blocks.length ? `. latest: ${blocks[blocks.length - 1].reason.replace(/^blocked: /, '')}` : ''}`);
+    if (waiting) console.log(`  ${waiting} event${waiting === 1 ? '' : 's'} waiting to be sent to your dashboard`);
+    console.log('');
+    return 0;
+  }
+  if (sub === 'test') {
+    const guard = require('../lib/sentinel-guard');
+    const rows = guard.runSamples({ env });
+    if (opts.json) { console.log(JSON.stringify(rows, null, 2)); return rows.every((r) => r.ok) ? 0 : 1; }
+    console.log('\n  sample commands through the sentinel guard rules\n');
+    for (const r of rows) {
+      const mark = r.ok ? ' ' : '!';
+      console.log(`  ${mark} ${r.got === 'block' ? 'blocked' : 'allowed'}  ${r.command}`);
+      if (r.got === 'block') console.log(`             ${r.reason.replace(/^blocked: /, '')}`);
+    }
+    const bad = rows.filter((r) => !r.ok);
+    const blocked = rows.filter((r) => r.got === 'block').length;
+    console.log('');
+    console.log(`  ${blocked} of ${rows.length} samples blocked, ${rows.length - blocked} allowed`);
+    console.log(bad.length ? `  ${bad.length} sample${bad.length === 1 ? '' : 's'} did not do what was expected (marked !)` : '  every sample did what was expected');
+    console.log('');
+    return bad.length ? 1 : 0;
+  }
+  console.error(`  unknown guard command: ${sub}. use install, uninstall, status or test`);
+  return 2;
+}
+
+// ---------------------------------------------------------------- flush
+
+async function flushCommand(argv, deps = {}) {
+  const quiet = argv.includes('--quiet');
+  const events = require('../lib/sentinel-events');
+  const token = tokenFor(deps);
+  let res;
+  try { res = await events.flushQueue({ token, base: deps.base, env: deps.env || process.env }); } catch (e) { res = { ok: false, reason: e.message, sent: 0 }; }
+  if (!quiet) {
+    if (res.ok) console.log(`  sent ${res.sent} queued event${res.sent === 1 ? '' : 's'} to your atris dashboard`);
+    else console.log(`  warning: queued events were not sent: ${res.reason}. they stay queued for next time`);
+  }
+  return 0;
+}
+
+// ---------------------------------------------------------------- scheduled
+
+// What a scheduled run does before the paid review: the two free checks,
+// wrapped in scan_started and scan_finished events. Never throws.
+async function runScheduledFreeChecks(root, deps = {}) {
+  const events = require('../lib/sentinel-events');
+  const upload = deps.upload !== false;
+  const token = upload ? tokenFor(deps) : '';
+  const repo = events.repoName(root);
+  const started = new Date();
+  const say = deps.log || ((m) => console.log(m));
+  const out = { agents: null, watch: null, sent: [] };
+  const send = async (list) => {
+    if (!upload) return { ok: true, skipped: 'no-upload' };
+    if (!token) return { ok: false, reason: 'not logged in' };
+    try { return await events.postEvents(list, { token, base: deps.base }); } catch (e) { return { ok: false, reason: e.message }; }
+  };
+  const startEv = events.makeEvent({ kind: 'scan_started', repo, severity: 'info', title: 'Sentinel started its scheduled check of this project.', status: 'resolved', fingerprint: events.fingerprint('scan_started', repo, started.toISOString()), occurredAt: started });
+  out.sent.push(await send([startEv]));
+  try {
+    out.agents = await runAgents(root, { home: false, upload, deps: { ...deps, token } });
+    say(`  agent setup check: ${out.agents.result.grade}, ${out.agents.result.findings.length} finding${out.agents.result.findings.length === 1 ? '' : 's'}`);
+  } catch (e) { say(`  warning: the agent setup check did not finish: ${e.message}`); }
+  try {
+    out.watch = await runWatchCheck(root, { upload, deps: { ...deps, token } });
+    if (out.watch.result.offline) say('  warning: the dependency check could not reach the osv database this time');
+    else say(`  dependency check: ${out.watch.result.affected.length} affected package${out.watch.result.affected.length === 1 ? '' : 's'}`);
+  } catch (e) { say(`  warning: the dependency check did not finish: ${e.message}`); }
+  const agentsOpen = out.agents ? out.agents.result.findings.length : 0;
+  const threats = out.watch && !out.watch.result.offline ? out.watch.result.affected.length : 0;
+  const bad = (out.agents && out.agents.result.grade === 'fail') || (out.watch && out.watch.result.affected.some((a) => a.severity === 'critical' || a.severity === 'high'));
+  const title = events.fillPlain('Sentinel finished its scheduled check. {a} agent setup findings and {t} dependency threats are open.', { a: ['count', String(agentsOpen), 'some'], t: ['count', String(threats), 'some'] });
+  const finished = new Date();
+  const endEv = events.makeEvent({ kind: 'scan_finished', repo, severity: bad ? 'high' : 'info', title, status: 'resolved', fingerprint: events.fingerprint('scan_finished', repo, started.toISOString()), occurredAt: finished });
+  out.sent.push(await send([endEv]));
+  if (upload && token) { try { await events.flushQueue({ token, base: deps.base, env: deps.env || process.env }); } catch {} }
+  return out;
+}
+
+module.exports = { agentsCommand, guardCommand, watchCommand, flushCommand, runScheduledFreeChecks, runAgents, runWatchCheck };

package/commands/task.js

@@ -5963,6 +5963,9 @@ function isUninitializedTaskFolder(cwd = process.cwd()) {
 
 function cmdNext(args) {
   const root = process.cwd();
+  const { buildAgentNext, printAgentNext } = require('../lib/agent-next');
+  const agent = buildAgentNext({ root, args });
+  if (agent) return printAgentNext(agent, { asJson: wantsJson(args), alias: 'command' });
   // Empty folder talks like bare atris. Walk up like the task db so a
   // project subdir stays in the room; stop before inheriting /tmp.
   // A leftover projection with live tasks still names that work.
@@ -12244,7 +12247,7 @@ async function run(args) {
   // `task next --help` is a help request, not a run. Next can open
   // the task db or print the desk, so never list or claim just to show usage.
   if (sub === 'next' && argsWantHelp(raw.slice(1))) {
-    console.log('Usage: atris task next [--tag <tag>] [--create-next]');
+    console.log('Usage: atris task next [--tag <tag>] [--agent <member>|--human] [--create-next]');
     return;
   }
   // `task show --help` is a help request, not a run. Show can dump
@@ -12254,13 +12257,17 @@ async function run(args) {
     return;
   }
   const result = await runTaskCommand(raw);
-  const skipsRender = hasFlag(raw, '--dry-run');
+  const readOnlyAgentNext = sub === 'next' && require('../lib/agent-next').agentCaller(raw.slice(1));
+  const skipsRender = hasFlag(raw, '--dry-run') || readOnlyAgentNext;
   if (MUTATING_TASK_COMMANDS.has(sub) && !skipsRender) autoRenderTodoFromDb();
   return result;
 }
 
 module.exports = {
   run,
+  taskQueueScopeFromArgs,
+  normalizeTaskQueueScope,
+  filterTasksByScope,
   chooseTaskOwner,
   readTeamMembers,
   createTaskApiServer,