atris 3.37.1 → 3.40.0

package/commands/clean.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const escapeRegExp = require('../lib/escape-regexp');
+const { wikiMetabolismNudge } = require('../lib/wiki');
 
 /**
  * atris clean - Workspace housekeeping with auto-heal
@@ -60,6 +61,14 @@ function cleanAtris(options = {}) {
   const stalePages = findStalePages(cwd, atrisDir);
   results.stalePages = stalePages;
 
+  // 6. Dead code report (report-only: deletion is a human/reviewed call)
+  try {
+    const { findDeadCode } = require('./slop');
+    const dead = findDeadCode(cwd);
+    results.deadFiles = dead.dead.map((f) => path.relative(cwd, f));
+    results.testOnlyFiles = dead.testOnly.map((f) => path.relative(cwd, f));
+  } catch { results.deadFiles = []; results.testOnlyFiles = []; }
+
   if (options.json) {
     console.log(JSON.stringify(cleanResultPayload(results, options, cwd), null, 2));
     return results;
@@ -75,6 +84,12 @@ function cleanAtris(options = {}) {
   console.log('Results:');
   console.log('');
 
+  const wikiNudge = wikiMetabolismNudge(cwd);
+  if (wikiNudge) {
+    console.log(wikiNudge);
+    console.log('');
+  }
+
   // Stale tasks
   if (staleTasks.length > 0) {
     console.log(`⚠ ${staleTasks.length} stale ${staleTasks.length === 1 ? 'task' : 'tasks'} (claimed >3 days, not completed):`);
@@ -140,6 +155,16 @@ function cleanAtris(options = {}) {
     console.log('✓ No stale wiki pages');
   }
 
+  // Dead code
+  if ((results.deadFiles || []).length > 0) {
+    console.log(`⚠ ${results.deadFiles.length} dead ${results.deadFiles.length === 1 ? 'file' : 'files'} (unreachable and unreferenced — atris slop dead for detail):`);
+    results.deadFiles.slice(0, 5).forEach((f) => console.log(`   • ${f}`));
+    if (results.deadFiles.length > 5) console.log(`   ... and ${results.deadFiles.length - 5} more`);
+    console.log('');
+  } else {
+    console.log('✓ No dead code');
+  }
+
   const hasIssues = staleTasks.length > 0 || unhealable.length > 0 || stalePages.length > 0;
   if (hasIssues) {
     console.log('Manual action needed:');
@@ -165,6 +190,7 @@ function cleanResultPayload(results, options = {}, cwd = process.cwd()) {
   if (results.staleTasks.length > 0) manualAction.push('Delete stale tasks or finish them');
   if (results.unhealableRefs.length > 0) manualAction.push('Manually fix unhealable MAP.md refs');
   if (results.stalePages.length > 0) manualAction.push('Re-compile stale pages');
+  if ((results.deadFiles || []).length > 0) manualAction.push('Delete dead files (atris slop dead)');
   return {
     ok: manualAction.length === 0,
     action: 'clean',
@@ -196,6 +222,11 @@ function cleanResultPayload(results, options = {}, cwd = process.cwd()) {
           stale_source: page.staleSource,
         })),
       },
+      dead_code: {
+        count: (results.deadFiles || []).length,
+        items: results.deadFiles || [],
+        test_only: results.testOnlyFiles || [],
+      },
     },
     manual_action: manualAction,
   };
@@ -659,8 +690,6 @@ module.exports = {
   cleanResultPayload,
   findStaleTasks,
   healBrokenMapRefs,
-  archiveOldJournals,
-  cleanEmptySections,
   findStalePages,
   checkPageStaleness
 };

package/commands/close.js

@@ -517,14 +517,27 @@ function pulseLivenessState(cwd, now) {
 // pulse liveness check only sees silence; this sees a run of negative reward.
 // Sums reward over the last N finished ticks; unhealthy when the trend is net
 // negative, healthy once it climbs back to zero or better.
+//
+// Recency guard: this sensor only speaks to a *live* run of ticks. A
+// decommissioned or intermittent loop leaves stale receipts frozen; without a
+// guard the last N finished ticks stay net-negative forever and the flag can
+// never clear (no fresh positive receipt arrives). It also must not treat a
+// scattered set — e.g. one tick today plus five from days ago — as a "run":
+// summing rewards across a multi-day gap is meaningless. So we only consider
+// finished ticks from the last few days and require a full window of them; a
+// silent or sparse loop is the pulse-liveness sensor's concern, and here it
+// reports healthy so any open reward flag auto-closes.
 const REWARD_REGRESSION_WINDOW = 6;
+const REWARD_REGRESSION_RECENCY_MS = 2 * DAY_MS;
 
 function rewardRegressionState(cwd, now) {
   const receipts = pulse.readJsonl(pulse.pulseReceiptsPath(cwd));
   const finished = receipts
     .filter((r) => r && r.phase === 'finished' && parseDate(r.ts || r.at) !== null)
+    .filter((r) => now.getTime() - parseDate(r.ts || r.at) <= REWARD_REGRESSION_RECENCY_MS)
     .sort((a, b) => parseDate(a.ts || a.at) - parseDate(b.ts || b.at));
-  if (finished.length < REWARD_REGRESSION_WINDOW) return { healthy: false, unhealthy: false };
+  // Not enough recent signal to call a degradation run: leave it to pulse liveness.
+  if (finished.length < REWARD_REGRESSION_WINDOW) return { healthy: true, unhealthy: false, sparse: true };
   const window = finished.slice(-REWARD_REGRESSION_WINDOW);
   const sum = window.reduce((acc, r) => acc + (Number(r.reward) || 0), 0);
   return { healthy: sum >= 0, unhealthy: sum < 0, sum };
@@ -782,13 +795,14 @@ function appendOpenedFromSource({ what, owner = 'operator', lane = 'code', ttlDa
   return event;
 }
 
-function appendClosedFromSource(flag, cwd, now) {
+function appendClosedFromSource(flag, cwd, now, note) {
   const event = {
     kind: 'closed',
     at: now.toISOString(),
     id: flag.id,
     proof: RESOLVED_IN_SOURCE_PROOF,
   };
+  if (note) event.note = note;
   appendEvent(event, cwd);
   return event;
 }
@@ -809,12 +823,20 @@ function scanState(cwd = process.cwd(), options = {}) {
   const lessonFlags = lessonFlagsState(cwd, now);
   const openBySource = new Map();
   const dissolvedSources = new Set();
+  const recentlyClosedSources = new Set();
   const autoClosed = [];
 
   // Dissolve is a durable verdict: a source the operator declared dead on
-  // purpose must never re-open on a later scan.
+  // purpose must never re-open on a later scan. Recent closes get a 30-day
+  // quiet period so a resolved source cannot immediately breed a new flag.
   for (const flag of foldEvents(readEvents(cwd), { now })) {
     if (flag.status === 'dissolved' && flag.source) dissolvedSources.add(flag.source);
+    const closedAt = parseDate(flag.closed_at);
+    const closedAge = closedAt === null ? null : now.getTime() - closedAt;
+    if (flag.status === 'closed' && flag.source && closedAge !== null
+      && closedAge >= 0 && closedAge <= 30 * DAY_MS) {
+      recentlyClosedSources.add(flag.source);
+    }
   }
 
   const failedTasks = Array.from(tasksById.values())
@@ -827,17 +849,22 @@ function scanState(cwd = process.cwd(), options = {}) {
     if (flag.source) openBySource.set(flag.source, flag);
   }
 
-  const closeFlag = (flag) => {
-    const event = appendClosedFromSource(flag, cwd, now);
+  const closeFlag = (flag, note) => {
+    const event = appendClosedFromSource(flag, cwd, now, note);
     autoClosed.push({ flag, event });
     openBySource.delete(flag.source);
+    recentlyClosedSources.add(flag.source);
   };
 
   for (const flag of Array.from(openBySource.values())) {
     if (flag.source.startsWith('task:')) {
       const task = tasksById.get(flag.source.slice('task:'.length));
       const status = normalizeSpaces(task && task.status).toLowerCase();
-      if (task && (taskResolved(task) || status === 'failed')) closeFlag(flag);
+      if (!task) {
+        closeFlag(flag, 'task no longer in projection (done/archived)');
+      } else if (!taskWaitingOnHumanAccept(task) || taskResolved(task) || status === 'failed') {
+        closeFlag(flag);
+      }
       continue;
     }
     if (flag.source.startsWith(FAILED_TASK_BATCH_PREFIX)) {
@@ -881,7 +908,8 @@ function scanState(cwd = process.cwd(), options = {}) {
 
   const opened = [];
   const openCandidate = (candidate) => {
-    if (!candidate.source || openBySource.has(candidate.source) || dissolvedSources.has(candidate.source)) return null;
+    if (!candidate.source || openBySource.has(candidate.source)
+      || dissolvedSources.has(candidate.source) || recentlyClosedSources.has(candidate.source)) return null;
     const event = appendOpenedFromSource(candidate, cwd, now);
     opened.push(event);
     openBySource.set(candidate.source, { ...event, status: 'open' });
@@ -889,10 +917,11 @@ function scanState(cwd = process.cwd(), options = {}) {
   };
 
   for (const task of tasks) {
-    const source = taskSource(task);
-    const ref = taskRef(task);
+    const currentTask = tasksById.get(normalizeSpaces(task && task.id));
+    const source = taskSource(currentTask);
+    const ref = taskRef(currentTask);
     if (!source || !ref) continue;
-    if (taskWaitingOnHumanAccept(task) && isOlderThan(task.updated_at, 5, now)) {
+    if (taskWaitingOnHumanAccept(currentTask) && isOlderThan(currentTask.updated_at, 5, now)) {
       openCandidate({
         what: `task ${ref} has waited in review too long, accept it or send it back`,
         lane: 'code',
@@ -1054,6 +1083,13 @@ function run(args = [], context = {}) {
       printHelp();
       return 0;
     }
+    // `close <sub> --help` is a help request, not a run — sweep and scan mutate
+    // the ledger (escalations, auto-closes), so never execute a subcommand just
+    // to show usage.
+    if (rest.includes('--help') || rest.includes('-h')) {
+      printHelp();
+      return 0;
+    }
     if (subcommand === 'add') return commandAdd(rest, context);
     if (subcommand === 'list') return commandList(rest, context);
     if (subcommand === 'done') return commandDone(rest, context);
@@ -1078,6 +1114,5 @@ module.exports = {
   openFlags,
   ledgerPath,
   readEvents,
-  listLine,
   sweepLine,
 };

package/commands/cloud.js

@@ -240,6 +240,5 @@ module.exports = {
   cloudClean,
   collectCloudOrphans,
   parseCloudCleanArgs,
-  readCloudCleanSlug,
   renderCloudCleanSummary,
 };

package/commands/codex-goal.js

@@ -2,15 +2,13 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { hasFlag } = require('../lib/arg-parser');
 
 const SCHEMA = 'atris.codex_goal.v1';
 const CONFIRM_RESET_FLAG = '--confirm-complete-goal-reset';
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-
-function readFlag(args, name, fallback = '') {
+// Preserve the existing rule that the next token is a value, even if it is a flag.
+function readFollowingFlag(args, name, fallback = '') {
   const index = args.indexOf(name);
   if (index === -1 || index + 1 >= args.length) return fallback;
   return args[index + 1];
@@ -32,7 +30,7 @@ function sqlString(value) {
 }
 
 function resolveStatePath(args = []) {
-  const explicit = readFlag(args, '--state', process.env.CODEX_STATE_DB || '');
+  const explicit = readFollowingFlag(args, '--state', process.env.CODEX_STATE_DB || '');
   if (explicit) return path.resolve(expandHome(explicit));
   // Codex moved native goals into ~/.codex/goals_1.sqlite; older builds kept them in state_5.sqlite.
   // Prefer the live goals DB so the bridge sees real goal activity, fall back to the legacy state DB.
@@ -43,7 +41,7 @@ function resolveStatePath(args = []) {
 
 // Thread metadata (cwd/title) stayed in state_5.sqlite even after goals moved to goals_1.sqlite.
 function resolveThreadsPath(args = []) {
-  const explicit = readFlag(args, '--threads-db', process.env.CODEX_THREADS_DB || '');
+  const explicit = readFollowingFlag(args, '--threads-db', process.env.CODEX_THREADS_DB || '');
   if (explicit) return path.resolve(expandHome(explicit));
   const legacyDb = path.join(os.homedir(), '.codex', 'state_5.sqlite');
   return fs.existsSync(legacyDb) ? path.resolve(legacyDb) : '';
@@ -79,7 +77,7 @@ function runGoalQuery(args, buildSql) {
 }
 
 function defaultRunsDir(args = []) {
-  return path.resolve(readFlag(args, '--out-dir', path.join(process.cwd(), '.atris', 'runs')));
+  return path.resolve(readFollowingFlag(args, '--out-dir', path.join(process.cwd(), '.atris', 'runs')));
 }
 
 function ensurePrivateDir(dir) {
@@ -196,7 +194,7 @@ function readRecentGoals(args, limit = 10) {
 }
 
 function resolveThreadGoal(args) {
-  const explicitThread = readFlag(args, '--thread', '');
+  const explicitThread = readFollowingFlag(args, '--thread', '');
   if (explicitThread) return readGoalByThread(args, explicitThread);
   if (hasFlag(args, '--latest')) return readLatestGoalForCwd(args, process.cwd());
   const envThread = process.env.CODEX_THREAD_ID || '';
@@ -248,7 +246,7 @@ function statusCommand(args) {
     return;
   }
 
-  const limit = Math.max(1, Math.min(50, Number(readFlag(args, '--limit', '10')) || 10));
+  const limit = Math.max(1, Math.min(50, Number(readFollowingFlag(args, '--limit', '10')) || 10));
   const goals = readRecentGoals(args, limit);
   const payload = { ok: true, schema: SCHEMA, action: 'status', state_path: dbPath, goals };
   printJsonOrText(payload, [
@@ -379,7 +377,5 @@ function codexGoalCommand(args = []) {
 
 module.exports = {
   codexGoalCommand,
-  CONFIRM_RESET_FLAG,
-  resolveStatePath,
   sqlString,
 };

package/commands/computer.js

@@ -1405,7 +1405,7 @@ function computerLocalLegacy(extraArgs = []) {
   }
 }
 
-function computerLocal(extraArgs = []) {
+function computerLocal(extraArgs = [], options = {}) {
   printLocalWordmark();
   printModeBanner('LOCAL', process.cwd(), [
     'Claude Code + Atris workspace context.',
@@ -1417,7 +1417,7 @@ function computerLocal(extraArgs = []) {
   const originalArgv = process.argv;
   process.argv = [originalArgv[0], originalArgv[1], originalArgv[2], 'claude', ...extraArgs];
   try {
-    consoleCommand();
+    consoleCommand(options);
   } finally {
     process.argv = originalArgv;
   }
@@ -4390,11 +4390,12 @@ async function runComputer(argv = process.argv.slice(3), deps = {}) {
 module.exports = {
   runComputer,
   computerSetup,
-  setupComputerChoices,
+  // `atris pack run` starts a packet as a free local computer, so it needs the
+  // local starter and the business-binding check as seams, not copies.
+  computerLocal,
+  readBusinessBinding,
   formatEngineSeats,
   buildComputerCard,
-  renderComputerCard,
-  renderComputerCardMarkdown,
   extractAttachedWorkspaceMismatch,
   contextForAttachedWorkspaceMismatch,
   printRecruitingLocalSyncOutcome,

package/commands/console.js

@@ -7,10 +7,40 @@ const { resolveClaudeRunnerBin } = require('../lib/runner-command');
 
 // ── Context Gathering ──────────────────────────────────────────────
 
+// Atris content lives in two shapes on disk, and the console has to read both.
+//
+//   workspace: <dir>/atris/{skills,team,TODO.md,...}
+//     The normal repo shape. A project keeps its Atris brain in a subfolder so
+//     it does not collide with the project's own files. This is the common case.
+//
+//   packet:    <dir>/{pack.json,skills,team,docs,...}
+//     A packet built in root mode (pack.js exports with prefix '' when the
+//     source dir has pack.json at its root — this is how the shipped packs are
+//     built and what the web /packs/<slug>/download route serves). `pack
+//     install` preserves that flat layout, so the packet folder IS the atris
+//     root; there is no nested atris/ to find.
+//
+// Nested wins when both exist: never change what an existing workspace loads.
+// Returns the directory that actually holds the atris content, or null.
+function resolveAtrisRoot(workspaceDir) {
+  const nested = path.join(workspaceDir, 'atris');
+  try {
+    if (fs.statSync(nested).isDirectory()) return nested;
+  } catch {}
+  const manifest = path.join(workspaceDir, 'pack.json');
+  try {
+    if (!fs.statSync(manifest).isFile()) return null;
+    JSON.parse(fs.readFileSync(manifest, 'utf8'));
+    return workspaceDir;
+  } catch {}
+  return null;
+}
+
 function gatherAtrisContext(workspaceDir) {
-  const atrisDir = path.join(workspaceDir, 'atris');
+  const atrisDir = resolveAtrisRoot(workspaceDir);
   const ctx = {
-    hasAtris: fs.existsSync(atrisDir),
+    hasAtris: Boolean(atrisDir),
+    atrisRoot: atrisDir,
     skills: [],
     teamMembers: [],
     backlogCount: 0,
@@ -119,7 +149,8 @@ function buildSystemPrompt(ctx) {
   if (ctx.teamMembers.length > 0) {
     lines.push('## Team Members');
     lines.push(`Available: ${ctx.teamMembers.join(', ')}`);
-    lines.push('Each has a MEMBER.md in atris/team/<name>/ defining their role.');
+    const teamRoot = ctx.atrisRoot ? path.join(ctx.atrisRoot, 'team') : 'atris/team';
+    lines.push(`Each has a MEMBER.md in ${teamRoot}/<name>/ defining their role.`);
     lines.push('');
   }
 
@@ -135,7 +166,8 @@ function buildSystemPrompt(ctx) {
 
   if (ctx.backlogCount > 0) {
     lines.push(`## Current Work`);
-    lines.push(`${ctx.backlogCount} task${ctx.backlogCount > 1 ? 's' : ''} in backlog. Check atris/TODO.md for details.`);
+    const todoPath = ctx.atrisRoot ? path.join(ctx.atrisRoot, 'TODO.md') : 'atris/TODO.md';
+    lines.push(`${ctx.backlogCount} task${ctx.backlogCount > 1 ? 's' : ''} in backlog. Check ${todoPath} for details.`);
     lines.push('');
   }
 
@@ -280,20 +312,37 @@ function checkAuth(backend) {
 
 // ── Launch ──────────────────────────────────────────────────────────
 
-function launchClaude(systemPrompt, extraArgs) {
+function launchClaude(systemPrompt, extraArgs, options = {}) {
+  const skipPermissions = options.skipPermissions !== false;
   const runnerBin = resolveClaudeRunnerBin();
+  const promptStdin = typeof options.promptStdin === 'string'
+    ? options.promptStdin
+    : null;
   const args = [
-    '--dangerously-skip-permissions',
+    ...(skipPermissions ? ['--dangerously-skip-permissions'] : []),
+    ...(promptStdin !== null ? ['--print'] : []),
     '--append-system-prompt', systemPrompt,
     ...extraArgs,
   ];
 
   const child = spawnSync(runnerBin, args, {
     cwd: process.cwd(),
-    stdio: 'inherit',
-    env: { ...process.env, CLAUDECODE: undefined },
+    stdio: promptStdin === null ? 'inherit' : ['pipe', 'inherit', 'inherit'],
+    ...(promptStdin === null ? {} : { input: promptStdin }),
+    env: { ...process.env, ...(options.runnerEnv || {}), CLAUDECODE: undefined },
   });
 
+  try {
+    if (typeof options.onRunnerExit === 'function') {
+      options.onRunnerExit({ status: child.status ?? 1, signal: child.signal || null });
+    }
+  } catch (error) {
+    console.error(`warning: could not finalize runner receipt: ${error.message}`);
+  }
+  for (const cleanupPath of options.cleanupPaths || []) {
+    try { fs.rmSync(cleanupPath, { recursive: true, force: true }); } catch {}
+  }
+
   if (child.error) {
     console.error(`✗ Failed to start ${runnerBin}: ${child.error.message}`);
     process.exit(1);
@@ -342,7 +391,11 @@ function launchCodex(systemPrompt, extraArgs) {
 
 // ── Main ────────────────────────────────────────────────────────────
 
-function consoleCommand() {
+// skipPermissions defaults to true: `atris console` runs on a workspace you
+// wrote. Callers that launch an agent inside content someone else authored
+// (`atris pack run`) pass false so permission prompts stay on.
+function consoleCommand(options = {}) {
+  const skipPermissions = options.skipPermissions !== false;
   const args = process.argv.slice(3);
   let requested = args[0];
 
@@ -385,7 +438,7 @@ function consoleCommand() {
 
     // Launch
     if (backend === 'claude') {
-      launchClaude(systemPrompt, extraArgs);
+      launchClaude(systemPrompt, extraArgs, { ...options, skipPermissions });
     } else {
       launchCodex(systemPrompt, extraArgs);
     }
@@ -399,4 +452,4 @@ function consoleCommand() {
   }
 }
 
-module.exports = { consoleCommand, gatherAtrisContext, buildSystemPrompt };
+module.exports = { consoleCommand, gatherAtrisContext, buildSystemPrompt, resolveAtrisRoot, launchClaude };

package/commands/decide.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const {
+  answerMissionHumanAsk,
+  listMissions,
+  listWorktreeRollupMissions,
+  pingMission,
+} = require('./mission');
+const { openHumanAsks, normalizeHumanAsks } = require('../lib/mission-human-asks');
+const { redirectToWorkspaceRoot } = require('../lib/mission-root');
+const { shortId } = require('../lib/short-name');
+
+const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
+
+function missionTouchedAt(mission) {
+  return String(mission.updated_at || mission.created_at || '');
+}
+
+function liveMissions(root = process.cwd()) {
+  const seen = new Set();
+  return [...listMissions(root), ...listWorktreeRollupMissions(root)]
+    .filter((mission) => {
+      if (!mission || !mission.id || seen.has(mission.id) || TERMINAL_STATUSES.has(mission.status)) return false;
+      seen.add(mission.id);
+      return true;
+    })
+    .sort((left, right) => (
+      missionTouchedAt(right).localeCompare(missionTouchedAt(left))
+      || String(left.id).localeCompare(String(right.id))
+    ));
+}
+
+function collectOpenDecisions(root = process.cwd()) {
+  const decisions = [];
+  for (const mission of liveMissions(root)) {
+    const normalized = normalizeHumanAsks(mission.human_asks);
+    normalized.forEach((ask, askIndex) => {
+      if (!ask.text.trim() || ask.answered_at) return;
+      decisions.push({
+        number: decisions.length + 1,
+        owner: String(mission.owner || 'unowned'),
+        mission_id: mission.id,
+        mission_short_id: shortId(mission.id),
+        mission_status: mission.status,
+        mission_updated_at: missionTouchedAt(mission),
+        ask_index: askIndex,
+        text: ask.text,
+      });
+    });
+  }
+  return decisions;
+}
+
+function printHelp() {
+  console.log('Usage:');
+  console.log('  atris decide');
+  console.log('  atris decide <n> y|n|yes|no [--note "<text>"]');
+  console.log('  atris decide --json');
+  console.log('  atris decide <n> y --json');
+}
+
+function fail(message, asJson, code = 2) {
+  if (asJson) {
+    console.log(JSON.stringify({ ok: false, action: 'decide_error', error: message }));
+  } else {
+    console.error(message);
+  }
+  process.exitCode = code;
+}
+
+function parseArgs(args) {
+  const asJson = args.includes('--json');
+  const rest = args.filter((arg) => arg !== '--json');
+  let note = '';
+  const noteIndex = rest.findIndex((arg) => arg === '--note' || String(arg).startsWith('--note='));
+  if (noteIndex !== -1) {
+    const noteArg = String(rest[noteIndex]);
+    if (noteArg === '--note') {
+      if (rest[noteIndex + 1] == null) return { asJson, error: '--note requires text' };
+      note = String(rest[noteIndex + 1]).trim();
+      rest.splice(noteIndex, 2);
+    } else {
+      note = noteArg.slice('--note='.length).trim();
+      rest.splice(noteIndex, 1);
+    }
+  }
+  return { asJson, note, rest };
+}
+
+function decideCommand(args = []) {
+  redirectToWorkspaceRoot();
+  const parsed = parseArgs(args);
+  if (parsed.error) return fail(parsed.error, parsed.asJson);
+  const { asJson, note, rest } = parsed;
+  if (rest.includes('--help') || rest.includes('-h') || rest[0] === 'help') {
+    printHelp();
+    return;
+  }
+
+  const decisions = collectOpenDecisions();
+  if (!rest.length) {
+    if (asJson) {
+      console.log(JSON.stringify({
+        ok: true,
+        action: 'decide_list',
+        count: decisions.length,
+        decisions,
+      }, null, 2));
+    } else if (!decisions.length) {
+      console.log('nothing is waiting for a decision.');
+    } else {
+      for (const decision of decisions) {
+        console.log(`[${decision.number}] ${decision.owner} · ${decision.mission_short_id} · ${decision.text}`);
+      }
+      console.log('atris decide <n> y|n');
+    }
+    return;
+  }
+
+  if (rest.length !== 2) {
+    return fail('usage: atris decide <n> y|n|yes|no [--note "<text>"]', asJson);
+  }
+  const number = Number(rest[0]);
+  if (!Number.isInteger(number) || number < 1) {
+    return fail('decision number must be a positive integer', asJson);
+  }
+  const answerToken = String(rest[1]).toLowerCase();
+  const answer = answerToken === 'y' || answerToken === 'yes'
+    ? 'yes'
+    : (answerToken === 'n' || answerToken === 'no' ? 'no' : null);
+  if (!answer) return fail('answer must be y, n, yes, or no', asJson);
+  const decision = decisions[number - 1];
+  if (!decision) return fail(`decision ${number} is not open`, asJson, 1);
+
+  const message = `Decision on "${decision.text}": ${answer.toUpperCase()}${note ? ` — ${note}` : ''}`;
+  pingMission([decision.mission_id, message, '--from', 'decide'], { silent: true });
+  const mission = answerMissionHumanAsk(decision.mission_id, decision.ask_index, answer, note);
+  const remainingOpenAsks = openHumanAsks(mission.human_asks).length;
+  const payload = {
+    ok: true,
+    action: 'decision_answered',
+    decision: {
+      ...decision,
+      answer,
+      note,
+      message,
+    },
+    mission: {
+      id: mission.id,
+      short_id: decision.mission_short_id,
+      owner: mission.owner,
+      status: mission.status,
+      remaining_open_asks: remainingOpenAsks,
+    },
+  };
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(`sent to ${decision.mission_short_id}: ${message}`);
+    console.log(`mission ${decision.mission_short_id} will read it on its next tick.`);
+  }
+}
+
+module.exports = {
+  decideCommand,
+};