atris 3.15.48 → 3.15.50

package/atris/wiki/index.md

@@ -12,6 +12,7 @@
 - [[atris/wiki/concepts/intent-capability-composition.md]] — the operating loop; roadmap from gaps
 - [[atris/wiki/concepts/wiki-as-memory-substrate.md]] — what `atris/wiki/` is and isn't
 - [[atris/wiki/concepts/plan-do-review-loop.md]] — core Atris workflow and how local memory fits into it
+- [[atris/wiki/concepts/rebased-pack-co-first-loop.md]] — local-only business workspace first loop and proof guardrails
 - [[atris/wiki/concepts/atris-labs-goals.md]] — atris-labs north star, 2026 Q2 targets, standing constraints
 - [[atris/wiki/concepts/horizon-types.md]] — horizon slug prefix convention; type categories and inference rules
 - [[atris/wiki/concepts/verifiable-reward-loop.md]] — reward, scorecards, and why the repo now acts like an RL-style environment
@@ -21,6 +22,7 @@
 
 ## Briefs
 
+- [[atris/wiki/briefs/rebased-pack-co-starter-brief.md]] — starter brief for the local-only Rebased Pack Co smoke workspace
 - [[atris/wiki/briefs/atris-cli-overview.md]] — summary of CLI, owner/computer model, workspace layers, and why `atris/wiki/` exists
 - [[atris/wiki/briefs/atris-labs-workspace-protocol.md]] — atris-labs workspace protocol: on-load sequence, layout, surfaces, north star
 - [[atris/wiki/briefs/atrisos-generative-ui-product-surface.md]] — historical AtrisOS generative UI / block surface design note

package/bin/atris.js

@@ -334,6 +334,7 @@ function showHelp() {
   console.log('  now        - Show atris/now.md, the current operating truth');
   console.log('  activate   - Load Atris context');
   console.log('  radar      - Show live agents joined with tasks, missions, and worktrees');
+  console.log('  ctop       - Show a process-first live agent CPU/memory view');
   console.log('  status     - See local work and completions (`atris status <business>` for remote)');
   console.log('  xp         - Show Career XP and contribution graph');
   console.log('  analytics  - Show recent productivity from journals');
@@ -765,7 +766,7 @@ if (command === '2' && ['fast', 'pro'].includes(String(firstCommandArg || '').to
 }
 
 // Check if this is a known command or natural language input
-const knownCommands = ['init', 'log', 'now', 'radar', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'log', 'now', 'radar', 'ctop', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'chat', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'verify', 'search', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync',
                        'ingest', 'query', 'lint', 'loop', 'task', 'mission', 'worktree', 'aeo', 'xp', 'play', 'gm', 'x',
@@ -1182,8 +1183,9 @@ if (command === 'init') {
   Promise.resolve(require('../commands/worktree').worktreeCommand(process.argv.slice(3)))
     .then((code) => process.exit(code || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
-} else if (command === 'radar') {
-  Promise.resolve(require('../commands/radar').radarCommand(process.argv.slice(3)))
+} else if (command === 'radar' || command === 'ctop') {
+  const radarArgs = command === 'ctop' ? ['--agents', ...process.argv.slice(3)] : process.argv.slice(3);
+  Promise.resolve(require('../commands/radar').radarCommand(radarArgs))
     .then((code) => process.exit(code || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'codex-goal') {

package/commands/brain.js

@@ -183,7 +183,7 @@ function countTodoItems(todoText) {
     if (!isTitled) continue;
 
     titled += 1;
-    if (hasRenderedSections && ['Backlog', 'In Progress', 'Blocked'].includes(section)) renderedOpen += 1;
+    if (hasRenderedSections && ['Backlog', 'In Progress'].includes(section)) renderedOpen += 1;
     if (hasRenderedSections && section === 'Completed') renderedDone += 1;
   }
 
@@ -195,6 +195,70 @@ function countTodoItems(todoText) {
   };
 }
 
+const EXECUTABLE_TASK_STATUSES = new Set(['open', 'claimed']);
+const COMPLETED_TASK_STATUSES = new Set(['done', 'completed', 'accepted']);
+
+function readTaskProjectionTasks(root) {
+  const projection = readJson(path.join(root, '.atris', 'state', 'tasks.projection.json'));
+  const tasks = Array.isArray(projection?.tasks) ? projection.tasks : null;
+  return tasks || null;
+}
+
+function isCertifiedReviewTask(task) {
+  if (String(task?.status || '').toLowerCase() !== 'review') return false;
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  const passCount = Number(metadata.agent_review_pass_count || review.agent_review_pass_count || 0);
+  return Boolean(metadata.agent_certified || review.agent_certified || passCount >= 2);
+}
+
+function summarizeTaskProjection(root) {
+  const tasks = readTaskProjectionTasks(root);
+  if (!tasks) return null;
+
+  const counts = {};
+  const certifiedReviewTasks = [];
+  for (const task of tasks) {
+    const status = String(task?.status || '').toLowerCase();
+    counts[status] = (counts[status] || 0) + 1;
+    if (isCertifiedReviewTask(task)) {
+      certifiedReviewTasks.push({
+        ref: task.display_id || task.legacy_ref || task.id,
+        title: task.title || 'Untitled task',
+      });
+    }
+  }
+
+  return {
+    tasks,
+    counts,
+    certifiedReviewTasks,
+  };
+}
+
+function countTaskProjectionItems(root) {
+  const summary = summarizeTaskProjection(root);
+  if (!summary) return null;
+
+  let open = 0;
+  let done = 0;
+  for (const [status, count] of Object.entries(summary.counts)) {
+    if (EXECUTABLE_TASK_STATUSES.has(status)) open += count;
+    if (COMPLETED_TASK_STATUSES.has(status)) done += count;
+  }
+
+  return {
+    open,
+    checked: done,
+    titled: summary.tasks.length,
+    done,
+  };
+}
+
+function countWorkItems(root, todoText) {
+  return countTaskProjectionItems(root) || countTodoItems(todoText);
+}
+
 function listMarkdown(root, relDir, limit = 12) {
   const dir = path.join(root, relDir);
   if (!fs.existsSync(dir)) return [];
@@ -271,7 +335,8 @@ function collectState(root) {
     name: business.name || business.slug || firstHeading(status || mapText, path.basename(root)),
     slug: business.slug || path.basename(root),
     business,
-    todo: countTodoItems(todoText),
+    todo: countWorkItems(root, todoText),
+    taskProjection: summarizeTaskProjection(root),
     hasNow: nowText.length > 0,
     nowHeading: firstHeading(nowText, null),
     hasMap: mapText.length > 0,
@@ -292,7 +357,7 @@ function collectState(root) {
 }
 
 function prepareBrainState(root) {
-  refreshNowFile(root);
+  refreshNowFile(root, { preserveCustom: true });
   return collectState(root);
 }
 
@@ -482,6 +547,12 @@ function memberNextMove(member, state = null) {
   const name = member.name || member.slug;
   const context = `${member.startHere}\n${member.goals}`;
   const identity = `${member.slug}\n${member.name}`;
+  const certifiedReview = state?.taskProjection?.certifiedReviewTasks?.[0] || null;
+  const certifiedReviewMove = certifiedReview
+    ? `${name}: hand off certified review ${certifiedReview.ref} to the operator: run ` +
+      `\`atris task accept ${certifiedReview.ref}\` if approved or ` +
+      `\`atris task revise ${certifiedReview.ref} --note "<what must change>"\` if not; do not create new work until this checkpoint is clear.`
+    : null;
   if (member.slug === 'justin' || /justin/i.test(member.name || '')) {
     return `${name}: run one customer-moving GTM rep, update the relevant workspace state within 10 minutes, and leave a scorecard.`;
   }
@@ -496,6 +567,7 @@ function memberNextMove(member, state = null) {
     return `${name}: choose or create one bounded mission step, run its verifier, and close it with proof, a scorecard, and the next move.`;
   }
   if (/validator|reviewer/i.test(identity)) {
+    if (certifiedReviewMove) return certifiedReviewMove;
     if ((state?.todo?.open || 0) === 0 && (state?.todo?.done || 0) === 0) {
       return `${name}: wait for one concrete artifact or ask Navigator to create a reviewable task with verifier, proof target, and residual-risk checklist.`;
     }
@@ -503,6 +575,7 @@ function memberNextMove(member, state = null) {
   }
   if (/executor|builder/i.test(identity)) {
     if ((state?.todo?.open || 0) === 0) {
+      if (certifiedReviewMove) return certifiedReviewMove;
       return `${name}: ask Navigator to create one bounded task with files, verifier, and stop rule before making a patch.`;
     }
     return `${name}: execute the highest-leverage claimed task one scoped step at a time, run the verifier after the patch, and hand off proof for review.`;
@@ -511,6 +584,7 @@ function memberNextMove(member, state = null) {
     return `${name}: turn one messy or unclaimed intent into a MAP-backed plan with ASCII visualization, exact files, verifier, rollback, and a review-ready task.`;
   }
   if (/launcher|closer/i.test(identity)) {
+    if (certifiedReviewMove) return certifiedReviewMove;
     if ((state?.todo?.done || 0) === 0) {
       return `${name}: wait for one validated task receipt before closeout, or ask Validator to produce a review decision with proof.`;
     }

package/commands/computer.js

@@ -544,6 +544,7 @@ function parseComputerOptions(argv) {
   let workspaceId = null;
   let waitForResult = true;
   let message = null;
+  let force = false;
 
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -600,6 +601,10 @@ function parseComputerOptions(argv) {
       waitForResult = false;
       continue;
     }
+    if (arg === '--force') {
+      force = true;
+      continue;
+    }
     positional.push(arg);
   }
 
@@ -618,6 +623,7 @@ function parseComputerOptions(argv) {
       workspaceId: workspaceId ? String(workspaceId).trim() : null,
       waitForResult,
       message,
+      force,
     },
   };
 }
@@ -1174,7 +1180,8 @@ function printComputerCommandFailure(result, ctx = null) {
   if (result?.status === 409) {
     const mismatch = extractAttachedWorkspaceMismatch(detail, result?.data);
     const targetWorkspace = mismatch?.requestedWorkspaceId || ctx?.workspaceId || '<workspace-id>';
-    console.error(`Run: atris computer activate --business ${businessSelector(ctx)} --workspace ${targetWorkspace}`);
+    const forceFlag = /--force|force to take over|re-run with --force/i.test(detail) ? ' --force' : '';
+    console.error(`Run: atris computer activate --business ${businessSelector(ctx)} --workspace ${targetWorkspace}${forceFlag}`);
   }
 }
 
@@ -1253,6 +1260,17 @@ function formatWorkspaceRef(workspace) {
   return workspace.name ? `${workspace.name} (${workspace.id})` : workspace.id;
 }
 
+function formatLeaseAge(seconds) {
+  const value = Number(seconds);
+  if (!Number.isFinite(value) || value < 0) return '-';
+  if (value < 60) return `${Math.floor(value)}s`;
+  const minutes = Math.floor(value / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+
 async function probeAttachedWorkspace(token, ctx) {
   const result = await apiRequestJson(
     `/business/${ctx.businessId}/workspaces/${ctx.workspaceId}/terminal`,
@@ -1272,7 +1290,7 @@ async function probeAttachedWorkspace(token, ctx) {
   return { workspaceId: null, health: 'degraded', result };
 }
 
-async function bootstrapBusinessComputerRuntime(token, ctx, boundary = 'computer-wake') {
+async function bootstrapBusinessComputerRuntime(token, ctx, boundary = 'computer-wake', options = {}) {
   if (!ctx?.businessId || !ctx?.workspaceId) {
     return { ok: false, skipped: true, reason: 'missing_workspace' };
   }
@@ -1288,8 +1306,10 @@ async function bootstrapBusinessComputerRuntime(token, ctx, boundary = 'computer
   });
   const result = await runBusinessTerminalCommand(token, ctx, command, 120);
   if (!result.ok) {
-    console.log('  Runtime: bootstrap could not run.');
-    console.log(`  Recovery: atris computer run "npm install --prefix /workspace/.atris-npm atris@latest && /workspace/.atris-npm/node_modules/.bin/atris update" --business ${ctx.slug || ctx.businessId} --workspace ${ctx.workspaceId}`);
+    if (!options.quiet) {
+      console.log('  Runtime: bootstrap could not run.');
+      console.log(`  Recovery: atris computer run "npm install --prefix /workspace/.atris-npm atris@latest && /workspace/.atris-npm/node_modules/.bin/atris update" --business ${ctx.slug || ctx.businessId} --workspace ${ctx.workspaceId}`);
+    }
     return { ok: false, result };
   }
 
@@ -1297,13 +1317,15 @@ async function bootstrapBusinessComputerRuntime(token, ctx, boundary = 'computer
   const output = String(data.stdout || data.output || data.result || '').trim();
   const line = output.split('\n').find((entry) => entry.includes('atris_runtime_bootstrap'));
   const recovery = output.split('\n').find((entry) => entry.startsWith('recovery='));
-  if (line) {
-    console.log(`  Runtime: ${line.replace(/^atris_runtime_bootstrap\s*/, '')}`);
-  } else {
-    console.log('  Runtime: Atris bootstrap receipt written.');
-  }
-  if (recovery) {
-    console.log(`  Recovery: atris computer run "${recovery.slice('recovery='.length)}" --business ${ctx.slug || ctx.businessId} --workspace ${ctx.workspaceId}`);
+  if (!options.quiet) {
+    if (line) {
+      console.log(`  Runtime: ${line.replace(/^atris_runtime_bootstrap\s*/, '')}`);
+    } else {
+      console.log('  Runtime: Atris bootstrap receipt written.');
+    }
+    if (recovery) {
+      console.log(`  Recovery: atris computer run "${recovery.slice('recovery='.length)}" --business ${ctx.slug || ctx.businessId} --workspace ${ctx.workspaceId}`);
+    }
   }
   return { ok: true, output };
 }
@@ -1457,12 +1479,12 @@ async function runBusinessPromptViaRunnerProxy(token, ctx, prompt, options = {})
   return { ok: false, error: 'runner proxy timed out', status: 0 };
 }
 
-async function ensureBusinessAwake(token, ctx, maxWaitSec = 90) {
+async function ensureBusinessAwake(token, ctx, maxWaitSec = 90, options = {}) {
   const status = await apiRequestJson(`/business/${ctx.businessId}/ai-computer/status`, { method: 'GET', token });
   if (status.ok && status.data && status.data.status === 'running' && status.data.endpoint) {
     return true;
   }
-  process.stdout.write('  Waking business computer... ');
+  if (!options.quiet) process.stdout.write('  Waking business computer... ');
   await apiRequestJson(`/business/${ctx.businessId}/ai-computer/wake`, { method: 'POST', token, body: {} });
   const start = Date.now();
   while (Date.now() - start < maxWaitSec * 1000) {
@@ -1470,12 +1492,12 @@ async function ensureBusinessAwake(token, ctx, maxWaitSec = 90) {
     const next = await apiRequestJson(`/business/${ctx.businessId}/ai-computer/status`, { method: 'GET', token });
     if (next.ok && next.data && next.data.status === 'running' && next.data.endpoint) {
       const elapsed = Math.floor((Date.now() - start) / 1000);
-      console.log(`awake (${elapsed}s)`);
-      await bootstrapBusinessComputerRuntime(token, ctx, 'computer-auto-wake');
+      if (!options.quiet) console.log(`awake (${elapsed}s)`);
+      await bootstrapBusinessComputerRuntime(token, ctx, 'computer-auto-wake', options);
       return true;
     }
   }
-  console.log('timeout');
+  if (!options.quiet) console.log('timeout');
   return false;
 }
 
@@ -1500,10 +1522,24 @@ async function computerStatus(token, ctx = null) {
     const targetWorkspace = workspaces.find((workspace) => workspace.id === ctx.workspaceId) || (ctx.workspaceId ? { id: ctx.workspaceId } : null);
     console.log(`    Default workspace:  ${formatWorkspaceRef(defaultWorkspace)}`);
     console.log(`    Target workspace:   ${formatWorkspaceRef(targetWorkspace)}`);
+    const attachedFromStatus = d.attached_workspace_id
+      ? { workspaceId: d.attached_workspace_id, health: null }
+      : null;
+    if (attachedFromStatus) {
+      const attachedWorkspace = workspaces.find((workspace) => workspace.id === attachedFromStatus.workspaceId)
+        || { id: attachedFromStatus.workspaceId, name: d.attached_workspace_name || null };
+      console.log(`    Attached workspace: ${formatWorkspaceRef(attachedWorkspace)}`);
+      console.log(`    Attached by:        ${d.attached_by || '-'}`);
+      console.log(`    Attached at:        ${d.attached_at || '-'}`);
+      console.log(`    Lease age:          ${formatLeaseAge(d.lease_age_seconds)}`);
+      if (d.takeover_hint) console.log(`    Takeover hint:      ${d.takeover_hint}`);
+    }
     if (status === 'running' && d.endpoint && ctx.workspaceId) {
       const attached = await probeAttachedWorkspace(token, ctx);
-      const attachedWorkspace = workspaces.find((workspace) => workspace.id === attached.workspaceId) || (attached.workspaceId ? { id: attached.workspaceId } : null);
-      console.log(`    Attached workspace: ${formatWorkspaceRef(attachedWorkspace)}`);
+      if (!attachedFromStatus) {
+        const attachedWorkspace = workspaces.find((workspace) => workspace.id === attached.workspaceId) || (attached.workspaceId ? { id: attached.workspaceId } : null);
+        console.log(`    Attached workspace: ${formatWorkspaceRef(attachedWorkspace)}`);
+      }
       if (attached.health === 'workspace_mismatch') {
         printComputerCommandFailure(attached.result, ctx);
       } else if (attached.health !== 'ready') {
@@ -1686,7 +1722,7 @@ async function computerCreate(token, args = [], defaults = {}) {
   console.log(`  atris computer sleep --business ${owner} --workspace ${workspaceId}`);
 }
 
-async function computerActivate(token, ctx = null) {
+async function computerActivate(token, ctx = null, options = {}) {
   if (!ctx?.businessId || !ctx?.workspaceId) {
     console.error('Usage: atris computer activate --business <slug> --workspace <id>');
     process.exitCode = 1;
@@ -1696,7 +1732,7 @@ async function computerActivate(token, ctx = null) {
   const result = await apiRequestJson(`/business/${ctx.businessId}/workspaces/${ctx.workspaceId}/activate`, {
     method: 'POST',
     token,
-    body: {},
+    body: { force: Boolean(options.force) },
   });
   if (!result.ok) {
     printComputerCommandFailure(result, ctx);
@@ -2420,7 +2456,7 @@ async function computerAudit(token, ctx, limit = 10) {
   printBusinessChatAudit(result.data?.rows || []);
 }
 
-async function streamBusinessChatResult(token, ctx, executionId, rl = null) {
+async function streamBusinessChatResult(token, ctx, executionId, rl = null, options = {}) {
   let fromIndex = 0;
   let errors = 0;
   let cancelling = false;
@@ -2458,7 +2494,7 @@ async function streamBusinessChatResult(token, ctx, executionId, rl = null) {
   const sigintTarget = rl || process;
   sigintTarget.on('SIGINT', onSigint);
 
-  console.log(ui.dim('Running on cloud. Ctrl-C interrupts this run.'));
+  if (!options.quiet) console.log(ui.dim('Running on cloud. Ctrl-C interrupts this run.'));
 
   try {
     while (true) {
@@ -2486,7 +2522,7 @@ async function streamBusinessChatResult(token, ctx, executionId, rl = null) {
         } else if (event.type === 'result' && event.result && !sawVisibleOutput) {
           sawVisibleOutput = true;
           process.stdout.write(String(event.result));
-        } else if (event.type === 'tool_use' && event.tool) {
+        } else if (!options.quiet && event.type === 'tool_use' && event.tool) {
           const arg = event.input?.file_path || event.input?.path || event.input?.pattern || event.input?.command || '';
           if (arg) {
             console.log(`\n  [${event.tool}] ${String(arg).slice(0, 120)}`);
@@ -2566,7 +2602,7 @@ async function sendBusinessChat(token, ctx, message, sessionId, resetContext = f
   const nextSessionId = data.session_id || sessionId;
   if (rl) rl.pause();
   try {
-    await streamBusinessChatResult(token, ctx, data.execution_id, rl);
+    await streamBusinessChatResult(token, ctx, data.execution_id, rl, { quiet: Boolean(options.quiet) });
   } finally {
     if (rl) rl.resume();
   }
@@ -2581,31 +2617,36 @@ async function computerChat(token, ctx, initialOptions = {}) {
   }
 
   const isCodeOps = initialOptions.mode === 'codeops' || ctx.slug === 'atris-codeops';
+  const oneShotMessage = initialOptions.message != null;
   const chatSystemPrompt = isCodeOps
     ? appendSystemPrompt(initialOptions.systemPrompt, CODEOPS_WORKFLOW_PROMPT)
     : initialOptions.systemPrompt;
   let sessionId = `biz-${ctx.businessId.slice(0, 8)}-${Date.now().toString(36)}`;
   const pipedInput = initialOptions.message != null ? null : await readPipedStdin();
   const scriptedInput = initialOptions.message != null ? String(initialOptions.message) : pipedInput;
-  printCloudWordmark();
-  const selection = await chooseCloudLane(token, ctx, initialOptions);
+  if (!oneShotMessage) printCloudWordmark();
+  const selection = oneShotMessage
+    ? { worker: initialOptions.worker, model: initialOptions.model }
+    : await chooseCloudLane(token, ctx, initialOptions);
   if (selection.cancelled) return;
   let worker = activeWorker(selection.worker);
   let model = selection.model || null;
   let awaitingLoginCode = false;
-  let billingLabel = await describeBillingMode(token, ctx, worker);
-  let authSummary = activeWorker(worker) === 'claude' ? await describeClaudeAuth(token, ctx) : null;
+  let billingLabel = oneShotMessage ? null : await describeBillingMode(token, ctx, worker);
+  let authSummary = oneShotMessage || activeWorker(worker) !== 'claude' ? null : await describeClaudeAuth(token, ctx);
 
-  const awake = await ensureBusinessAwake(token, ctx);
+  const awake = await ensureBusinessAwake(token, ctx, 90, { quiet: oneShotMessage });
   if (!awake) {
     console.error('  Computer did not become ready in time.');
     return;
   }
 
-  if (isCodeOps) {
-    printCodeOpsStartPanel(ctx, worker, model, billingLabel, authSummary);
-  } else {
-    printCloudStartPanel(ctx, worker, model, billingLabel, authSummary);
+  if (!oneShotMessage) {
+    if (isCodeOps) {
+      printCodeOpsStartPanel(ctx, worker, model, billingLabel, authSummary);
+    } else {
+      printCloudStartPanel(ctx, worker, model, billingLabel, authSummary);
+    }
   }
 
   if (scriptedInput !== null) {
@@ -2640,6 +2681,7 @@ async function computerChat(token, ctx, initialOptions = {}) {
         model,
         systemPrompt: chatSystemPrompt,
         allowedTools: initialOptions.allowedTools,
+        quiet: oneShotMessage,
       });
     }
     return;
@@ -3392,7 +3434,7 @@ async function runComputer() {
     case 'chat': return computerChat(token, ctx, cloudOptions);
     case 'card': return computerCard(args.slice(1));
     case 'proof': return computerProof(token, ctx, cloudOptions);
-    case 'activate': return computerActivate(token, ctx);
+    case 'activate': return computerActivate(token, ctx, cloudOptions);
     case 'status': return computerStatus(token, ctx);
     case 'up':
     case 'wake': return computerWake(token, ctx);

package/commands/mission.js

@@ -7,6 +7,7 @@ const { spawn, spawnSync } = require('child_process');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
+const GOAL_LOOP_STATUSES = new Set(['planning', 'running', 'ready']);
 const STATUS_ALIASES = new Set(['active']);
 
 function stampIso() {
@@ -763,7 +764,7 @@ function secondsUntilMissionDue(mission, now = new Date()) {
 }
 
 function missionIsRunnable(mission) {
-  return mission && !TERMINAL_STATUSES.has(mission.status) && mission.status !== 'paused';
+  return mission && GOAL_LOOP_STATUSES.has(String(mission.status || ''));
 }
 
 function missionSortTime(mission) {

package/commands/now.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 
 const NOW_PATH = path.join('atris', 'now.md');
+const EXECUTABLE_TASK_STATUSES = new Set(['open', 'claimed']);
 
 function formatLocalDate(date = new Date()) {
   const year = String(date.getFullYear());
@@ -79,7 +80,7 @@ function countOpenTodoItems(filePath) {
     }
     const isTaskBullet = /^-\s+(?:\[[ ]\]\s+)?\*\*.+?\*\*/.test(line);
     if (!isTaskBullet) continue;
-    if (!hasRenderedSections || ['Backlog', 'In Progress', 'Blocked'].includes(section)) {
+    if (!hasRenderedSections || ['Backlog', 'In Progress'].includes(section)) {
       count += 1;
     }
   }
@@ -87,6 +88,25 @@ function countOpenTodoItems(filePath) {
   return count;
 }
 
+function countTaskProjectionItems(root = process.cwd()) {
+  const projectionPath = path.join(root, '.atris', 'state', 'tasks.projection.json');
+  if (!fs.existsSync(projectionPath)) return null;
+  try {
+    const projection = JSON.parse(fs.readFileSync(projectionPath, 'utf8'));
+    const tasks = Array.isArray(projection?.tasks) ? projection.tasks : null;
+    if (!tasks) return null;
+    return tasks.filter(task => EXECUTABLE_TASK_STATUSES.has(String(task?.status || '').toLowerCase())).length;
+  } catch {
+    return null;
+  }
+}
+
+function countOpenWorkItems(root = process.cwd(), todoPath = path.join(root, 'atris', 'TODO.md')) {
+  const projectionCount = countTaskProjectionItems(root);
+  if (projectionCount !== null) return projectionCount;
+  return countOpenTodoItems(todoPath);
+}
+
 function countJournalCompletedReceipts(filePath) {
   if (!fs.existsSync(filePath)) return 0;
   const content = fs.readFileSync(filePath, 'utf8');
@@ -107,7 +127,7 @@ function renderDefaultNow(root = process.cwd()) {
   const mapHeading = readFirstHeading(path.join(atrisDir, 'MAP.md')) || 'MAP not filled yet';
   const todoPath = path.join(atrisDir, 'TODO.md');
   const journalPath = currentJournalPath(root);
-  const openTodoCount = countOpenTodoItems(todoPath);
+  const openTodoCount = countOpenWorkItems(root, todoPath);
   const inboxCount = countMatches(journalPath, /^-\s+\*\*I\d+:/gm);
   const completedCount = countJournalCompletedReceipts(journalPath);
   const generated = todayIso();
@@ -161,7 +181,7 @@ function renderPortfolioNow(root = process.cwd()) {
   const generated = todayIso();
   const lines = workspaces.map((workspace) => {
     const heading = readFirstHeading(workspace.mapPath) || workspace.slug;
-    const todoCount = countOpenTodoItems(workspace.todoPath);
+    const todoCount = countOpenWorkItems(workspace.root, workspace.todoPath);
     const nowState = fs.existsSync(workspace.nowPath) ? 'has now.md' : 'needs now.md';
     return `- ${workspace.slug}: ${heading}; ${todoCount} open TODO item${todoCount === 1 ? '' : 's'}; ${nowState}.`;
   });
@@ -201,6 +221,18 @@ ${workspaces.map((workspace) => `- \`${workspace.slug}/atris/MAP.md\``).join('\n
 `;
 }
 
+function isGeneratedNowFile(content) {
+  const text = String(content || '');
+  const hasGeneratedSignature = (
+    text.includes('> Current operating truth for this workspace.') ||
+    text.includes('> Current operating truth for this portfolio of Atris workspaces.')
+  ) && text.includes('## Receipts');
+  const hasLegacyGeneratedCounters = /^#\s+now\s*$/m.test(text)
+    && /Open TODO items:\s*\d+/m.test(text)
+    && /Completed receipts today:\s*\d+/m.test(text);
+  return hasGeneratedSignature || hasLegacyGeneratedCounters;
+}
+
 function ensureNowFile(root = process.cwd()) {
   let atrisDir = path.join(root, 'atris');
   const isWorkspace = fs.existsSync(atrisDir) && hasWorkspaceMarkers(atrisDir);
@@ -220,7 +252,7 @@ function ensureNowFile(root = process.cwd()) {
   return { created: false, path: nowPath };
 }
 
-function refreshNowFile(root = process.cwd()) {
+function refreshNowFile(root = process.cwd(), options = {}) {
   const atrisDir = path.join(root, 'atris');
   const isWorkspace = fs.existsSync(atrisDir) && hasWorkspaceMarkers(atrisDir);
   const childWorkspaces = isWorkspace ? [] : findChildWorkspaces(root);
@@ -231,9 +263,15 @@ function refreshNowFile(root = process.cwd()) {
     fs.mkdirSync(atrisDir, { recursive: true });
   }
   const nowPath = path.join(atrisDir, 'now.md');
+  if (options.preserveCustom && fs.existsSync(nowPath)) {
+    const current = fs.readFileSync(nowPath, 'utf8');
+    if (!isGeneratedNowFile(current)) {
+      return { path: nowPath, preserved: true };
+    }
+  }
   const content = isWorkspace ? renderDefaultNow(root) : renderPortfolioNow(root);
   fs.writeFileSync(nowPath, content, 'utf8');
-  return { path: nowPath };
+  return { path: nowPath, preserved: false };
 }
 
 function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
@@ -295,8 +333,10 @@ module.exports = {
   ensureNowFile,
   formatLocalDate,
   countJournalCompletedReceipts,
+  countOpenWorkItems,
   countOpenTodoItems,
   findChildWorkspaces,
+  isGeneratedNowFile,
   nowAtris,
   refreshNowFile,
   renderDefaultNow,

package/commands/radar.js

@@ -128,6 +128,45 @@ function loadTasks(root, deps) {
   }));
 }
 
+function findTaskWorkspaceRoot(cwd, deps) {
+  if (!cwd) return null;
+  let current = path.resolve(cwd);
+  for (let depth = 0; depth < 8; depth += 1) {
+    if (deps.exists(path.join(current, '.atris', 'state', 'tasks.projection.json'))) return current;
+    const parent = path.dirname(current);
+    if (!parent || parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+function loadTasksCached(root, deps, cache) {
+  if (!root) return [];
+  if (!cache.has(root)) cache.set(root, loadTasks(root, deps));
+  return cache.get(root);
+}
+
+function untaskedReason(agent, taskWorkspaceRoot, tasks) {
+  if (!agent.cwd) return 'cwd unknown';
+  if (!taskWorkspaceRoot) return 'no task projection';
+  if (!tasks.length) return 'empty task projection';
+  return 'no active task';
+}
+
+function shellQuote(value) {
+  return `'${String(value || '').replace(/'/g, "'\\''")}'`;
+}
+
+function untaskedAction(agent, taskWorkspaceRoot, tasks) {
+  const reason = untaskedReason(agent, taskWorkspaceRoot, tasks);
+  const pid = agent.pid || '?';
+  const actor = agent.agent || 'agent';
+  if (reason === 'cwd unknown') return `inspect pid ${pid} cwd with lsof`;
+  if (reason === 'no active task') return `cd ${shellQuote(taskWorkspaceRoot)} && atris task next --as ${actor}`;
+  if (reason === 'empty task projection') return `cd ${shellQuote(taskWorkspaceRoot)} && atris task new "<small concrete title>" --tag ops`;
+  return `inspect ${agent.cwd || 'unknown cwd'} for missing Atris task plane or close pid ${pid} if idle`;
+}
+
 function readJsonFile(file, deps, fallback = null) {
   if (!deps.exists(file)) return fallback;
   return safeJson(deps.readFile(file, 'utf8'), fallback);
@@ -369,10 +408,12 @@ function taskRef(task) {
   return task ? (task.display_id || task.legacy_ref || task.id || '-') : '-';
 }
 
-function taskForCwd(tasks, cwd) {
-  if (!cwd) return null;
-  return tasks.find(task => task.workspace_root === cwd && ['claimed', 'open'].includes(task.status))
-    || tasks.find(task => task.workspace_root === cwd && task.status === 'review')
+function taskForCwd(tasks, cwd, workspaceRoot = cwd) {
+  if (!cwd && !workspaceRoot) return null;
+  const matchesWorkspace = task => !task.workspace_root || task.workspace_root === cwd || task.workspace_root === workspaceRoot;
+  return tasks.find(task => matchesWorkspace(task) && task.status === 'claimed')
+    || tasks.find(task => matchesWorkspace(task) && task.status === 'open')
+    || tasks.find(task => matchesWorkspace(task) && task.status === 'review')
     || null;
 }
 
@@ -425,11 +466,23 @@ function collectRadar(options = {}) {
   };
   const nowMs = options.nowMs || Date.now();
   const tasks = loadTasks(root, deps);
+  const taskCache = new Map([[root, tasks]]);
   const missions = loadMissions(root, deps, nowMs);
   const worktrees = loadWorktrees(root, deps);
   const agents = collectAgents(deps).map(agent => {
-    const task = taskForCwd(tasks, agent.cwd);
-    return { ...agent, task: taskRef(task), task_status: task?.status || null, owner: ownerForTask(task) };
+    const taskWorkspaceRoot = findTaskWorkspaceRoot(agent.cwd, deps);
+    const agentTasks = taskWorkspaceRoot ? loadTasksCached(taskWorkspaceRoot, deps, taskCache) : [];
+    const task = taskForCwd(agentTasks, agent.cwd, taskWorkspaceRoot);
+    const taskReason = task ? null : untaskedReason(agent, taskWorkspaceRoot, agentTasks);
+    return {
+      ...agent,
+      task: taskRef(task),
+      task_status: task?.status || null,
+      owner: ownerForTask(task),
+      task_workspace: taskWorkspaceRoot ? repoLabel(taskWorkspaceRoot) : null,
+      task_reason: taskReason,
+      task_action: task ? null : untaskedAction(agent, taskWorkspaceRoot, agentTasks),
+    };
   });
   const osState = {
     xp: loadXp(root, deps),
@@ -523,24 +576,179 @@ function renderRadar(data) {
   return lines.join('\n');
 }
 
+function number(value) {
+  return Number.isFinite(Number(value)) ? Number(value) : 0;
+}
+
+function sortedAgents(agents = []) {
+  return [...agents].sort((a, b) => {
+    if (a.status !== b.status) return a.status === 'active' ? -1 : 1;
+    const cpuDelta = number(b.cpu) - number(a.cpu);
+    if (cpuDelta) return cpuDelta;
+    return String(a.repo || '').localeCompare(String(b.repo || ''));
+  });
+}
+
+function agentProcessNextAction(agents = [], fallback = 'no obvious process action') {
+  const stopped = agents.filter(agent => agent.status !== 'active').length;
+  if (stopped > 0) return `inspect ${stopped} stopped agent session${stopped === 1 ? '' : 's'}`;
+  const taskLoad = summarizeTaskLoad(agents);
+  const reviewBound = taskLoad.find(row => row.status.split(/,\s*/).includes('review'));
+  if (reviewBound) return `close or hand off ${reviewBound.sessions} session${reviewBound.sessions === 1 ? '' : 's'} still bound to review task ${reviewBound.task}`;
+  const pileup = taskLoad.find(row => row.sessions > 1);
+  if (pileup) return `inspect ${pileup.sessions} sessions on ${pileup.task} (${pileup.cpu.toFixed(1)}% CPU)`;
+  const untasked = agents.filter(agent => !agent.task || agent.task === '-').length;
+  if (untasked > 0) {
+    const reasons = summarizeUntaskedReasons(agents);
+    const summary = reasons.map(row => `${row.count} ${row.reason}`).join(', ');
+    return `resolve ${untasked} untasked session${untasked === 1 ? '' : 's'}${summary ? `: ${summary}` : ''}`;
+  }
+  const hot = agents.find(agent => number(agent.cpu) >= 50);
+  if (hot) return `inspect high-CPU ${hot.agent} ${hot.pid} in ${hot.repo || hot.cwd || 'unknown repo'}`;
+  return fallback;
+}
+
+function summarizeUntaskedReasons(agents = []) {
+  const counts = new Map();
+  for (const agent of agents) {
+    if (agent.task && agent.task !== '-') continue;
+    const reason = agent.task_reason || 'unmapped';
+    counts.set(reason, (counts.get(reason) || 0) + 1);
+  }
+  return [...counts.entries()]
+    .map(([reason, count]) => ({ reason, count }))
+    .sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason));
+}
+
+function summarizeTaskLoad(agents = []) {
+  const byTask = new Map();
+  for (const agent of agents) {
+    if (!agent.task || agent.task === '-') continue;
+    if (!byTask.has(agent.task)) {
+      byTask.set(agent.task, {
+        task: agent.task,
+        sessions: 0,
+        active: 0,
+        cpu: 0,
+        mem: 0,
+        statuses: new Set(),
+        owners: new Set(),
+        repos: new Set(),
+        pids: [],
+      });
+    }
+    const row = byTask.get(agent.task);
+    row.sessions += 1;
+    if (agent.status === 'active') row.active += 1;
+    row.cpu += number(agent.cpu);
+    row.mem += number(agent.mem);
+    if (agent.task_status) row.statuses.add(agent.task_status);
+    if (agent.owner && agent.owner !== '-') row.owners.add(agent.owner);
+    if (agent.repo) row.repos.add(agent.repo);
+    if (agent.pid) row.pids.push(agent.pid);
+  }
+  return [...byTask.values()]
+    .map(row => {
+      const statuses = [...row.statuses].sort();
+      return {
+        task: row.task,
+        sessions: row.sessions,
+        active: row.active,
+        cpu: Number(row.cpu.toFixed(1)),
+        mem: Number(row.mem.toFixed(1)),
+        status: statuses.join(', ') || '-',
+        owners: [...row.owners].sort(),
+        repos: [...row.repos].sort(),
+        pids: row.pids.sort((a, b) => number(a) - number(b)),
+        attention: row.sessions > 1 || statuses.includes('review'),
+      };
+    })
+    .sort((a, b) => Number(b.attention) - Number(a.attention) || b.sessions - a.sessions || b.cpu - a.cpu || a.task.localeCompare(b.task));
+}
+
+function agentTopPayload(data) {
+  const agents = sortedAgents(data.agents || []);
+  const untasked = agents.filter(agent => !agent.task || agent.task === '-').length;
+  const cpu = agents.reduce((sum, agent) => sum + number(agent.cpu), 0);
+  const mem = agents.reduce((sum, agent) => sum + number(agent.mem), 0);
+  const taskLoad = summarizeTaskLoad(agents);
+  return {
+    root: data.root,
+    generated_at: data.generated_at,
+    summary: {
+      total: agents.length,
+      active: agents.filter(agent => agent.status === 'active').length,
+      untasked,
+      untasked_reasons: summarizeUntaskedReasons(agents),
+      task_pileups: taskLoad.filter(row => row.sessions > 1).length,
+      review_bound_tasks: taskLoad.filter(row => row.status === 'review').length,
+      cpu: Number(cpu.toFixed(1)),
+      mem: Number(mem.toFixed(1)),
+    },
+    next_action: agentProcessNextAction(agents, data.next_action),
+    task_load: taskLoad,
+    agents,
+  };
+}
+
+function renderAgentTop(data) {
+  const payload = agentTopPayload(data);
+  const lines = [];
+  lines.push('Agent process top');
+  lines.push('');
+  lines.push(`Agents: ${payload.summary.active}/${payload.summary.total} active; ${payload.summary.untasked} untasked; CPU ${payload.summary.cpu.toFixed(1)}%; MEM ${payload.summary.mem.toFixed(1)}%`);
+  lines.push(`Next: ${payload.next_action}`);
+  lines.push('');
+  lines.push(`${truncate('PID', 7)} ${truncate('AGENT', 8)} ${truncate('CPU', 6)} ${truncate('MEM', 6)} ${truncate('REPO', 24)} ${truncate('BRANCH', 16)} ${truncate('TASK', 10)} ${truncate('STATE', 8)}`);
+  for (const agent of payload.agents.slice(0, 32)) {
+    lines.push(`${truncate(agent.pid, 7)} ${truncate(agent.agent, 8)} ${truncate(`${number(agent.cpu).toFixed(1)}%`, 6)} ${truncate(`${number(agent.mem).toFixed(1)}%`, 6)} ${truncate(agent.repo, 24)} ${truncate(agent.branch, 16)} ${truncate(agent.task, 10)} ${truncate(agent.status, 8)}`);
+  }
+  if (payload.agents.length > 32) lines.push(`... ${payload.agents.length - 32} more agents`);
+  if (payload.summary.untasked > 0) {
+    lines.push('');
+    const reasonText = payload.summary.untasked_reasons.map(row => `${row.count} ${row.reason}`).join(', ');
+    lines.push(`Untasked: ${payload.summary.untasked} sessions (${reasonText}).`);
+    for (const agent of payload.agents.filter(row => !row.task || row.task === '-').slice(0, 8)) {
+      lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'}: ${agent.task_reason || 'unmapped'} -> ${agent.task_action || 'inspect session'}`);
+    }
+  }
+  const taskLoadRows = payload.task_load.filter(row => row.attention).slice(0, 8);
+  if (taskLoadRows.length) {
+    lines.push('');
+    lines.push(`Task load: ${payload.summary.task_pileups} pileup${payload.summary.task_pileups === 1 ? '' : 's'}, ${payload.summary.review_bound_tasks} review-bound task${payload.summary.review_bound_tasks === 1 ? '' : 's'}.`);
+    for (const row of taskLoadRows) {
+      const repoText = row.repos.slice(0, 3).join(', ') || '-';
+      lines.push(`- ${row.task}: ${row.sessions} sessions, ${row.cpu.toFixed(1)}% CPU, ${row.status}, ${repoText}`);
+    }
+  }
+  return lines.join('\n');
+}
+
 function radarCommand(args = [], options = {}) {
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
-    console.log('Usage: atris radar [--json]');
+    console.log('Usage: atris radar [--json] [--agents]');
+    console.log('Usage: atris radar agents');
+    console.log('Usage: atris ctop');
     console.log('');
     console.log('Shows live agent processes joined with Atris tasks, missions, and worktrees.');
+    console.log('Use --agents or ctop for a process-first CPU/memory view.');
     return 0;
   }
   const data = collectRadar(options);
-  if (args.includes('--json')) console.log(JSON.stringify(data, null, 2));
+  const agentsOnly = args.includes('--agents') || args[0] === 'agents';
+  if (args.includes('--json')) console.log(JSON.stringify(agentsOnly ? agentTopPayload(data) : data, null, 2));
+  else if (agentsOnly) console.log(renderAgentTop(data));
   else console.log(renderRadar(data));
   return 0;
 }
 
 module.exports = {
   agentTypeForCommand,
+  agentTopPayload,
   collectRadar,
   parsePsOutput,
   parseWorktrees,
   radarCommand,
+  renderAgentTop,
   renderRadar,
 };

package/commands/task.js

@@ -79,6 +79,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task done <id> [--failed] [--proof "..."]  Mark complete (or failed), optionally reviewed
   atris task finish <id> [--proof "..."]   Legacy alias for done
   atris task review <id> --reward <n>      Write review event + RSI episode
+  atris task reviews [--limit <n>]         Show certified Review items for human accept/revise
   atris task status [--json] [--history]   Compact live status for web/Swarlo
   atris task setup [--import-todo]         Create/refresh task projection
   atris task serve [--port <n>]            Open local task factory board
@@ -878,6 +879,86 @@ function taskStatusSummary(projection, { history = false } = {}) {
   return status;
 }
 
+function reviewQueueLimit(args, total) {
+  if (hasFlag(args, '--all')) return total;
+  const raw = flag(args, '--limit');
+  const limit = raw && raw !== true ? Number(raw) : 12;
+  return Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 12;
+}
+
+function reviewQueueItem(task) {
+  const ref = taskRef(task);
+  return {
+    id: task.id,
+    display_id: task.display_id || null,
+    title: task.title,
+    tag: task.tag || null,
+    updated_at: task.updated_at || null,
+    review_pass_count: task.review?.agent_review_pass_count || null,
+    proof: task.review?.proof || null,
+    accept_command: `atris task accept ${ref}`,
+    revise_command: `atris task revise ${ref} --note "<what must change>"`,
+  };
+}
+
+function taskReviewQueue(projection, args = []) {
+  const reviewTasks = (projection.tasks || [])
+    .map(compactTaskForStatus)
+    .filter(task => task && task.status === 'review' && task.review && task.review.approval_status === 'pending')
+    .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0));
+  const blocking = reviewTasks.filter(task => task.review?.handoff?.next_action === 'agent_review_again');
+  const certified = reviewTasks.filter(task => task.review?.handoff?.next_action === 'continue_work' || task.review?.agent_certified === true);
+  const limit = reviewQueueLimit(args, certified.length);
+  const items = certified.slice(0, limit).map(reviewQueueItem);
+  return {
+    schema: 'atris.task_review_queue.v1',
+    generated_at: projection.generated_at,
+    workspace_root: projection.workspace_root,
+    counts: {
+      review: reviewTasks.length,
+      certified: certified.length,
+      blocking: blocking.length,
+      shown: items.length,
+    },
+    items,
+  };
+}
+
+function cmdReviews(args) {
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  const queue = taskReviewQueue(projection, args);
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'review_queue',
+      projection_path: outPath,
+      queue,
+    });
+    return;
+  }
+  console.log('CERTIFIED REVIEW QUEUE');
+  console.log(`${queue.counts.certified} certified / ${queue.counts.blocking} need agent review / ${queue.counts.review} total review`);
+  if (!queue.items.length) {
+    console.log('No certified review items.');
+    return;
+  }
+  queue.items.forEach((item, index) => {
+    const tag = item.tag ? ` [${item.tag}]` : '';
+    const passes = item.review_pass_count ? ` (${item.review_pass_count} reviews)` : '';
+    console.log('');
+    console.log(`${index + 1}. ${item.display_id || taskRef(item.id)}${tag}${passes}: ${item.title}`);
+    if (item.proof) console.log(`   proof: ${item.proof}`);
+    console.log(`   accept: ${item.accept_command}`);
+    console.log(`   revise: ${item.revise_command}`);
+  });
+  if (queue.counts.shown < queue.counts.certified) {
+    console.log('');
+    console.log(`Showing ${queue.counts.shown}/${queue.counts.certified}; rerun with --all or --limit ${queue.counts.certified}.`);
+  }
+}
+
 function humanEventType(type) {
   return String(type || 'event').replace(/_/g, ' ');
 }
@@ -2743,6 +2824,9 @@ async function run(args) {
     case 'finish': return cmdFinish(rest);
     case 'fail':   return cmdDone([...rest, '--failed']);
     case 'review': return cmdReview(rest);
+    case 'reviews':
+    case 'review-queue':
+      return cmdReviews(rest);
     case 'status': return cmdStatus(rest);
     case 'setup':  return cmdSetup(rest);
     case 'serve':  return cmdServe(rest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.15.48",
+  "version": "3.15.50",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",