atris 3.82.25 → 3.83.0

package/commands/doctor.js

@@ -175,34 +175,45 @@ function collectDoctor(options = {}) {
 }
 
 function renderDoctor(payload) {
-  const lines = [];
-  lines.push('atris doctor');
-  lines.push('');
-  lines.push(`version: ${payload.version_line || payload.version}`);
-  lines.push(`node: ${payload.node.version} (${payload.node.exec_path || 'unknown'})`);
-  lines.push(`task support (22+): ${payload.task_support ? 'yes' : 'no'}`);
-  lines.push(`auth: ${payload.auth.signed_in ? `signed in as ${payload.auth.email || 'unknown'}` : 'signed out'}`);
-  lines.push(`workspace: ${payload.workspace_root}`);
-  lines.push(`cli runnable: ${payload.cli_runnable ? 'yes' : 'no'}`);
-  lines.push(`public bin: ${payload.bin.public_bin} (${payload.bin.shim ? `${payload.bin.shim_bytes} byte shim` : 'not a shim'})`);
   const m = payload.members;
+  // Same rule as the boot screen: a folder is set up when it has an atris/ folder.
+  const setUp = fs.existsSync(path.join(payload.workspace_root, 'atris'));
+  const problems = [];
+  if (!payload.task_support) problems.push(`install node ${TASK_NODE_MAJOR} or newer  (atris tasks need it)`);
+  if (!payload.cli_runnable) problems.push('npm install -g atris  (reinstall atris; a program file is missing)');
+  if (!payload.bin.shim) problems.push('npm install -g atris  (reinstall atris; its startup file is damaged)');
+  if (!payload.auth.signed_in) problems.push('atris login  (sign in)');
+  if (!setUp) problems.push('atris init  (set up this folder)');
+  if (setUp && m && !m.members) problems.push('atris init  (add a team to this folder)');
+  if (m && !m.git_installed) problems.push('install git  (the team works on safe copies with it)');
+  else if (m && !m.git_repo) problems.push('git init  (let the team work on copies in this folder)');
+  if (m && !m.tools.length && !m.built_in_tool && payload.auth.signed_in) {
+    problems.push('install claude code or codex  (the team needs one coding tool)');
+  }
+  const count = problems.length;
+  const lines = [count ? `atris doctor: ${count === 1 ? 'one thing needs' : `${count} things need`} fixing.` : 'atris doctor: this computer is ready.', ''];
+  const row = (label, value) => `  ${label.padEnd(14)}${value}`;
+  lines.push(row('atris', `v${payload.version}`));
+  lines.push(row('node', payload.task_support
+    ? `${payload.node.version} (new enough; atris needs ${TASK_NODE_MAJOR} or newer)`
+    : `${payload.node.version} (too old; atris needs ${TASK_NODE_MAJOR} or newer; found at ${payload.node.exec_path || 'an unknown path'})`));
+  lines.push(row('signed in', payload.auth.signed_in ? (payload.auth.email || 'yes, account unknown') : 'no'));
+  lines.push(row('this folder', `${payload.workspace_root} (${setUp ? 'set up' : 'not set up'})`));
   if (m) {
-    const toolNames = m.tools.concat(m.built_in_tool ? ['built-in'] : []);
-    lines.push('');
-    lines.push(`members: ${m.ready ? 'ready' : 'not ready yet'}`);
-    lines.push(`  team: ${m.members ? `${m.members} member${m.members === 1 ? '' : 's'}` : 'none'}`);
-    lines.push(`  git: ${!m.git_installed ? 'not installed' : (m.git_repo ? 'yes' : 'installed, but this folder is not a git repo')}`);
-    lines.push(`  coding tool: ${toolNames.length ? toolNames.join(', ') : 'none'}`);
-    if (m.next) lines.push(`  next: ${m.next}`);
+    const tools = m.tools.concat(m.built_in_tool ? ['built-in'] : []);
+    lines.push(row('team', m.members ? `${m.members} member${m.members === 1 ? '' : 's'}` : 'none'));
+    lines.push(row('git', !m.git_installed ? 'not installed' : (m.git_repo ? 'yes' : 'installed; this folder has no git history')));
+    lines.push(row('coding tools', tools.length ? tools.join(', ') : 'none'));
   }
+  if (!payload.cli_runnable) lines.push(row('atris files', 'the program file is missing'));
+  if (!payload.bin.shim) lines.push(row('startup file', `${payload.bin.public_bin} is missing or unexpected (${payload.bin.shim_bytes === null ? 'size unknown' : `${payload.bin.shim_bytes} bytes`})`));
   if (payload.warnings && payload.warnings.length) {
-    lines.push('');
-    for (const warning of payload.warnings) lines.push(`warning: ${warning}`);
-  }
-  if (!payload.task_support) {
-    lines.push('');
-    lines.push(`install Node ${TASK_NODE_MAJOR}+ before running atris task.`);
+    for (const warning of payload.warnings) {
+      const plain = warning.replace('cli install is a dirty git checkout', 'the installed atris copy has unsaved changes').replace('cli install is a detached git checkout', 'the installed atris copy is not on a named branch');
+      lines.push(row('note', plain));
+    }
   }
+  if (count) lines.push('', `fix: ${problems[0]}`);
   return lines.join('\n');
 }
 
@@ -210,9 +221,10 @@ function doctorCommand(args = [], options = {}) {
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
     console.log('Usage: atris doctor [--json]');
     console.log('');
-    console.log('Reports node version, task-support (22+), auth, workspace root, and whether the CLI can run.');
-    console.log('Also checks what members need: a team, git, and a coding tool.');
-    console.log('Public install entry is bin/atris (tiny POSIX shim) -> bin/atris.js.');
+    console.log('Checks that this computer is ready: a new enough node, a working atris install,');
+    console.log('whether you are signed in and whether this folder is set up.');
+    console.log('Also checks what the team needs: members, git and a coding tool.');
+    console.log('--json prints the same facts for scripts.');
     return 0;
   }
   const payload = collectDoctor(options);

package/commands/init.js

@@ -344,16 +344,16 @@ function initAtris() {
     console.log(`workspace files ready (${ready.workspace.size})`);
     if (withTeam || ready.team.size > 0) {
       console.log(`team members ready (${ready.team.size})`);
-      console.log('more members are available with atris member create <name>');
+      console.log('add more members any time: atris member create <name>');
     }
     if (withAdapters || ready.adapters.size > 0) {
-      console.log(`agent adapters ready (${ready.adapters.size})`);
+      console.log(`set up for your coding tools (${ready.adapters.size})`);
     }
     if (withSkills || ready.skills.size > 0) {
       console.log(`skills installed (${ready.skills.size})`);
     }
     if (minimal) {
-      console.log('minimal scaffold (add --with-adapters / --with-skills or init --full for the rest)');
+      console.log('basic files ready (use --with-adapters or --with-skills to add more)');
     }
   };
   // GUARD: Refuse nested init.
@@ -1172,7 +1172,7 @@ Read atris/MAP.md. Begin iteration 1.`;
         if (saved.detail) console.log(`  git said: ${saved.detail.split('\n')[0]}`);
       }
     }
-    console.log('\natris initialized.');
+    console.log('\natris is set up in this folder.');
     console.log('no commands to learn. tell your agent what you want in plain words.');
   } else {
     console.error('✗ Error: atris.md not found in package');

package/commands/join.js

@@ -0,0 +1,159 @@
+'use strict';
+
+// atris join --name <name> [--business <id>] [--mission "<text>"]
+// Makes this session a named agent that lives on a home computer
+// (POST /join-as-agent). The agent key goes in the same slot `atris login
+// --agent` uses, and the joined agent is remembered next to it so
+// `atris night` and `atris morning` act for it by default.
+// Without --mission, the agent's purpose line from this project's own
+// atris/team/<name>/MISSION.md (its North Star) is shown and used as the mission.
+//
+// `atris join <invite-code>` (accepting an invite) still lives in
+// commands/social.js; bin/atris.js routes here only when --name is given.
+
+const path = require('path');
+const { parseFlags, wantsHelp, resolveBusinessId, errorText, cleanText } = require('../lib/night-shift');
+
+const NOT_LOGGED_IN = 'not logged in. run: atris login';
+
+function showJoinAgentHelp(log = console.log) {
+  log('usage: atris join --name <name> [--business <id>] [--mission "<text>"]');
+  log('');
+  log('Make this session a named agent that lives on a computer. With --business');
+  log('it joins that business\'s computer; without it, your personal computer.');
+  log('Running it again with the same name gives back the same agent.');
+  log('');
+  log('  --name <name>       The agent\'s name');
+  log('  --business <id>     The business it belongs to (id or connected slug)');
+  log('  --mission "<text>"  What the agent is for, in one line. Without it, the');
+  log('                      North Star in atris/team/<name>/MISSION.md is used if there');
+  log('                      is one. --mission "" sends no mission at all.');
+  log('');
+  log('To accept an invite instead: atris join <invite-code>');
+}
+
+// True when `atris join ...` means "join as an agent" rather than "accept an invite".
+function isAgentJoin(args = []) {
+  return Array.isArray(args) && args.some((arg) => arg === '--name' || String(arg).startsWith('--name='));
+}
+
+function homeLabel(data, businessInput) {
+  const home = data && data.home;
+  if (home && typeof home === 'object') {
+    const name = home.business_name || home.name || home.label;
+    if (name) return String(name);
+  }
+  if (businessInput) return String(businessInput);
+  if (typeof home === 'string' && home.trim() && !/^(self|personal)$/i.test(home.trim())) return home.trim();
+  return 'your personal computer';
+}
+
+function tokenExpiry(token, decode) {
+  const claims = decode(token);
+  if (claims && typeof claims.exp === 'number') return new Date(claims.exp * 1000).toISOString();
+  return null;
+}
+
+// Store the agent key where `atris login --agent` keeps scoped keys, plus the
+// joined agent itself. Returns a short note when it could not be saved.
+function storeJoinedAgent(creds, token, joined, deps = {}) {
+  if (!creds || creds.source) {
+    // Env tokens, placed key files, and agent clients are not ours to rewrite.
+    return 'The agent key was not saved because this terminal signs in with a key from outside. Keep it in ATRIS_TOKEN to act as the agent.';
+  }
+  const authUtils = require('../utils/auth');
+  const decode = deps.decodeJwtClaims || authUtils.decodeJwtClaims;
+  const persist = deps.persistMintedAgentToken || require('./auth').persistMintedAgentToken;
+  const claims = decode(token) || {};
+  try {
+    persist({ ...creds, joined_agent: joined }, token, {
+      scopes: Array.isArray(claims.scopes) ? claims.scopes : [],
+      expiresAt: tokenExpiry(token, decode),
+    });
+    return null;
+  } catch (error) {
+    return `The agent key was not saved: ${String(error && error.message || error)}`;
+  }
+}
+
+const MAX_MISSION = 300;
+
+// The one purpose line this project already keeps for an agent of this name:
+// the North Star in atris/team/<name>/MISSION.md. Null unless it is a real
+// line, not the placeholder a new member file starts with.
+function purposeFromFolder(name, cwd) {
+  const slug = String(name).trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+  if (!slug) return null;
+  const memberDir = path.join(cwd, 'atris', 'team', slug);
+  const { missionPurpose } = require('../lib/member-core');
+  const purpose = missionPurpose({ memberDir, missionFile: path.join(memberDir, 'MISSION.md') });
+  const line = purpose.meaningful ? cleanText(purpose.northStar, MAX_MISSION) : '';
+  return line.length >= 8 ? { file: `atris/team/${slug}/MISSION.md`, line } : null;
+}
+
+async function joinAgentCommand(args = [], deps = {}) {
+  const log = deps.log || console.log;
+  const err = deps.err || console.error;
+  if (wantsHelp(args)) {
+    showJoinAgentHelp(log);
+    return 0;
+  }
+
+  const { flags } = parseFlags(args, ['--name', '--business', '--mission'], []);
+  const name = String(flags.name || '').trim();
+  if (!name) {
+    err('Give the agent a name. Example: atris join --name scout');
+    return 1;
+  }
+
+  const load = deps.loadCredentials || require('../utils/auth').loadCredentials;
+  const request = deps.apiRequestJson || require('../utils/api').apiRequestJson;
+  const creds = await load(request);
+  const token = creds && typeof creds.token === 'string' ? creds.token.trim() : '';
+  if (!token) {
+    err(NOT_LOGGED_IN);
+    return 1;
+  }
+
+  const businessId = flags.business ? resolveBusinessId(flags.business, deps) : null;
+  const body = { business_id: businessId, name };
+  let mission = String(flags.mission || '').trim();
+  if (flags.mission === undefined) {
+    const purpose = purposeFromFolder(name, deps.cwd || process.cwd());
+    if (purpose) {
+      mission = purpose.line;
+      log(`Using the purpose line in ${purpose.file} as the mission:`);
+      log(`  "${purpose.line}"`);
+      log('Sending Atris only the name, the business and that one line, nothing else from your folder.');
+      log('To send your own instead: --mission "<text>". To send none: --mission "".');
+    }
+  }
+  if (mission) body.mission = mission;
+
+  const result = await request('/join-as-agent', { method: 'POST', token, body, retries: 0 });
+  if (!result || !result.ok) {
+    err(`Could not join: ${errorText(result)}`);
+    return 1;
+  }
+  const data = result.data || {};
+  if (!data.agent_id || !data.token) {
+    err('Atris did not return an agent and key, so nothing was joined.');
+    return 1;
+  }
+
+  const joined = {
+    agent_id: data.agent_id,
+    name,
+    business_id: businessId,
+    home: data.home == null ? null : data.home,
+    joined_at: deps.now ? deps.now() : new Date().toISOString(),
+  };
+  const note = storeJoinedAgent(creds, data.token, joined, deps);
+
+  log(`Joined ${homeLabel(data, flags.business)} as ${name}. This session now acts as that agent.`);
+  log(`Agent ${data.agent_id}.`);
+  if (note) err(note);
+  return 0;
+}
+
+module.exports = { joinAgentCommand, isAgentJoin, showJoinAgentHelp, storeJoinedAgent, purposeFromFolder };

package/commands/memory.js

@@ -21,8 +21,8 @@ const USAGE = [
   ...LIVE_HELP,
   'copy to laptop: atris memory <pull|push|status> [folder] [--json]',
   '  pull    copy your Atris memory folder down (default: ~/atris-memory)',
-  '  push    send back changes under wiki/ and files/ (any file under files/: photos, PDFs, recordings)',
-  '          --prune also removes pages under wiki/ and files/ that you deleted here',
+  '  push    send back changes under wiki/, files/ and features/ (any file under files/: photos, PDFs, recordings)',
+  '          --prune also removes pages under wiki/, files/ and features/ that you deleted here',
   '  status  show what changed here since the last pull',
 ].join('\n');
 

package/commands/morning.js

@@ -0,0 +1,132 @@
+'use strict';
+
+// atris morning [--business <id>] [--agent <id>] [--json] [--full] [--no-save]
+// Prints a short card for the last finished night shift (GET /morning) and
+// saves what the agent learned into this project's atris/ folder.
+
+const { parseFlags, wantsHelp, resolveTarget, errorText, cleanText, formatUsd } = require('../lib/night-shift');
+const { nightFromMorning, saveLearned, LEARNED_REL, LESSONS_REL } = require('../lib/night-learned');
+
+const NO_SHIFT = 'No night shift finished yet.';
+const NOT_LOGGED_IN = 'not logged in. run: atris login';
+
+function showMorningHelp(log = console.log) {
+  log('usage: atris morning [--business <id>] [--agent <id>] [--full] [--no-save] [--json]');
+  log('');
+  log('How your agent\'s last night went: the score, what it learned, and what it');
+  log('spent. What it learned is saved in this project\'s atris/ folder, in');
+  log(`${LEARNED_REL} (which a new session reads at start) and ${LESSONS_REL}.`);
+  log('Start a night with: atris night "<goal>"');
+  log('');
+  log('  --business <id>    Receipt for this business (id or connected slug)');
+  log('  --agent <id>       Receipt for this agent (default: the agent you joined as)');
+  log('  --full             Also print the full receipt: what it read, made and met');
+  log('  --no-save          Do not write anything into the atris/ folder');
+  log('  --json             Print the raw receipt as JSON (saves nothing)');
+}
+
+async function morningCommand(args = [], deps = {}) {
+  const log = deps.log || console.log;
+  const err = deps.err || console.error;
+  if (wantsHelp(args)) {
+    showMorningHelp(log);
+    return 0;
+  }
+
+  const { flags } = parseFlags(args, ['--business', '--agent'], ['--json', '--full', '--no-save']);
+  const load = deps.loadCredentials || require('../utils/auth').loadCredentials;
+  const request = deps.apiRequestJson || require('../utils/api').apiRequestJson;
+  const creds = await load(request);
+  const token = creds && typeof creds.token === 'string' ? creds.token.trim() : '';
+  if (!token) {
+    if (flags.json) log(JSON.stringify({ ok: false, error: NOT_LOGGED_IN }));
+    else err(NOT_LOGGED_IN);
+    return 1;
+  }
+
+  const { agentId, businessId } = resolveTarget(flags, creds, deps);
+  const query = new URLSearchParams();
+  if (businessId) query.set('business_id', businessId);
+  if (agentId) query.set('agent_id', agentId);
+  const qs = query.toString();
+  const result = await request(`/morning${qs ? `?${qs}` : ''}`, { method: 'GET', token });
+
+  const notFound = result && Number(result.status) === 404;
+  if (!notFound && (!result || !result.ok)) {
+    const message = errorText(result);
+    if (flags.json) log(JSON.stringify({ ok: false, error: message, status: result && result.status }));
+    else err(`Could not read the morning receipt: ${message}`);
+    return 1;
+  }
+
+  const data = (!notFound && result.data && typeof result.data === 'object') ? result.data : {};
+  const text = typeof data.text === 'string' ? data.text.replace(/\s+$/, '') : '';
+
+  if (flags.json) {
+    log(JSON.stringify(notFound ? { text: null, receipt: null } : data, null, 2));
+    return 0;
+  }
+  const night = notFound ? null : nightFromMorning(data);
+  if (!night) {
+    log(text || NO_SHIFT);
+    return 0;
+  }
+
+  let saved = null;
+  if (!flags['no-save']) saved = (deps.saveLearned || saveLearned)(deps.cwd || process.cwd(), night);
+  for (const line of renderCard(night, data, saved)) log(line);
+  if (flags.full && text) {
+    log('');
+    log(text);
+  }
+  return 0;
+}
+
+function headline(night) {
+  const goal = `Night on "${night.goal}"`;
+  if (night.score === null) return `${goal}: not scored.`;
+  const base = `${goal}: ${night.score} of 99`;
+  if (!night.known) return `${base}.`;
+  if (night.previous === null) return `${base}, first scored night.`;
+  // The server leaves the change out when the two nights were scored two
+  // different ways, so there is nothing fair to compare.
+  if (night.change === null) return `${base}.`;
+  if (night.change > 0) return `${base}, up from ${night.previous}.`;
+  if (night.change < 0) return `${base}, down from ${night.previous}.`;
+  return `${base}, the same as the night before.`;
+}
+
+function savedLine(night, saved) {
+  if (!saved) return 'Not saved to your folder (--no-save).';
+  if (saved.reason === 'no-folder') {
+    return 'Nothing saved: there is no atris/ folder here. Run this from your project to keep what it learned.';
+  }
+  if (saved.reason === 'error') return `Nothing saved: ${cleanText(saved.error, 120)}`;
+  if (!night.lines.length) return 'Nothing to save: the night learned nothing new.';
+  if (!saved.added) return `Nothing new to save: these notes are already in ${LEARNED_REL}.`;
+  const where = saved.lessons ? `${LEARNED_REL} and ${LESSONS_REL}` : LEARNED_REL;
+  return `Saved to your folder: ${saved.added} ${saved.added === 1 ? 'note' : 'notes'} (${where})`;
+}
+
+function renderCard(night, data, saved) {
+  const out = [headline(night)];
+  if (night.lines.length) {
+    out.push('Learned:');
+    for (const text of night.lines.slice(0, 3)) out.push(`- ${text}`);
+  } else {
+    out.push('Learned: nothing new recorded.');
+  }
+  if (night.lessons.length) {
+    const shown = night.lessons.slice(0, 3).map((name) => `"${name}"`).join(', ');
+    const more = night.lessons.length > 3 ? `, and ${night.lessons.length - 3} more` : '';
+    out.push(`Used ${night.lessons.length} ${night.lessons.length === 1 ? 'lesson' : 'lessons'}: ${shown}${more}`);
+  }
+  const receipt = data.receipt || {};
+  if (typeof receipt.spent_usd === 'number' && typeof receipt.cap_usd === 'number') {
+    out.push(`Spent ${formatUsd(receipt.spent_usd)} of the ${formatUsd(receipt.cap_usd)} cap.`);
+  }
+  out.push(savedLine(night, saved));
+  return out;
+}
+
+module.exports = { morningCommand, showMorningHelp, renderCard, NO_SHIFT };

package/commands/night.js

@@ -0,0 +1,178 @@
+'use strict';
+
+// atris night "<goal>" [--cap <usd>] [--business <id>] [--agent <id>] [--watch]
+// Starts a night shift on the home computer (POST /night-shift). The shift
+// stops on its own when it reaches the dollar cap.
+
+const {
+  parseFlags,
+  wantsHelp,
+  formatUsd,
+  resolveTarget,
+  errorText,
+} = require('../lib/night-shift');
+
+const DEFAULT_CAP_USD = 1;
+const POLL_MS = 60 * 1000;
+const FINAL_STATUSES = new Set(['capped', 'done', 'failed']);
+const MAX_POLL_FAILURES = 5;
+const NOT_LOGGED_IN = 'not logged in. run: atris login';
+
+function showNightHelp(log = console.log) {
+  log('usage: atris night "<goal>" [--cap <usd>] [--business <id>] [--agent <id>] [--watch]');
+  log('');
+  log('Give your agent a goal for tonight. It works on its home computer and');
+  log('stops when it has spent the cap. Read what it did with: atris morning');
+  log('');
+  log('  --cap <usd>        Most it may spend tonight, in dollars (default 1)');
+  log('  --business <id>    Run for this business (id or connected slug)');
+  log('  --agent <id>       Run as this agent (default: the agent you joined as)');
+  log('  --watch            Stay open and print each step until the shift ends');
+}
+
+function parseCap(raw) {
+  if (raw === undefined) return { ok: true, cap: DEFAULT_CAP_USD };
+  const text = String(raw).trim().replace(/^\$/, '');
+  const cap = text === '' ? NaN : Number(text);
+  if (!Number.isFinite(cap) || cap <= 0) return { ok: false };
+  return { ok: true, cap };
+}
+
+function formatStart(startsAt, now = new Date()) {
+  const when = startsAt ? new Date(startsAt) : null;
+  if (!when || Number.isNaN(when.getTime())) return startsAt ? String(startsAt) : 'once the computer is free';
+  const time = when.toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' });
+  const sameDay = when.toDateString() === now.toDateString();
+  if (sameDay) return time;
+  const day = when.toLocaleDateString([], { weekday: 'short', month: 'short', day: 'numeric' });
+  return `${time} ${day}`;
+}
+
+function shiftFrom(data) {
+  if (!data || typeof data !== 'object') return {};
+  return data.shift && typeof data.shift === 'object' ? data.shift : data;
+}
+
+function eventsFrom(data) {
+  if (!data || typeof data !== 'object') return [];
+  if (Array.isArray(data.events)) return data.events;
+  const shift = shiftFrom(data);
+  return Array.isArray(shift.events) ? shift.events : [];
+}
+
+function eventKey(event, index) {
+  if (event && typeof event === 'object' && (event.id || event.event_id)) return String(event.id || event.event_id);
+  return `#${index}`;
+}
+
+function eventLine(event) {
+  if (!event || typeof event !== 'object') return String(event);
+  const at = event.at || event.created_at || event.ts || event.timestamp;
+  const parsed = at ? new Date(at) : null;
+  const time = parsed && !Number.isNaN(parsed.getTime())
+    ? parsed.toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' })
+    : '';
+  const what = event.message || event.text || event.summary || event.detail || event.kind || event.type || 'step';
+  const spent = event.spent_usd != null ? ` (${formatUsd(event.spent_usd)} so far)` : '';
+  const line = `${String(what).replace(/\s+/g, ' ').trim()}${spent}`;
+  return time ? `${time}  ${line}` : line;
+}
+
+function finalLine(shift) {
+  const status = String(shift.status || 'done');
+  const spent = formatUsd(shift.spent_usd || 0);
+  const cap = formatUsd(shift.cap_usd || 0);
+  if (status === 'capped') return `The shift stopped at its cap. Spent ${spent} of ${cap}. Read it with: atris morning`;
+  if (status === 'failed') return `The shift failed after spending ${spent} of ${cap}.`;
+  return `The shift is done. Spent ${spent} of ${cap}. Read it with: atris morning`;
+}
+
+async function watchShift(shiftId, ctx) {
+  const { request, token, log, err, sleep, pollMs } = ctx;
+  const seen = new Set();
+  let failures = 0;
+  for (;;) {
+    const result = await request(`/night-shift/${encodeURIComponent(shiftId)}`, { method: 'GET', token });
+    if (!result || !result.ok) {
+      failures += 1;
+      err(`Could not check the shift: ${errorText(result)}`);
+      if (failures >= MAX_POLL_FAILURES) return 1;
+    } else {
+      failures = 0;
+      const events = eventsFrom(result.data);
+      events.forEach((event, index) => {
+        const key = eventKey(event, index);
+        if (seen.has(key)) return;
+        seen.add(key);
+        log(eventLine(event));
+      });
+      const shift = shiftFrom(result.data);
+      const status = String(shift.status || '').toLowerCase();
+      if (FINAL_STATUSES.has(status)) {
+        log(finalLine({ ...shift, status }));
+        return status === 'failed' ? 1 : 0;
+      }
+    }
+    await sleep(pollMs);
+  }
+}
+
+async function nightCommand(args = [], deps = {}) {
+  const log = deps.log || console.log;
+  const err = deps.err || console.error;
+  if (wantsHelp(args)) {
+    showNightHelp(log);
+    return 0;
+  }
+
+  const { flags, positionals } = parseFlags(args, ['--cap', '--business', '--agent'], ['--watch']);
+  const goal = positionals.join(' ').trim();
+  if (!goal) {
+    err('Say what to learn tonight. Example: atris night "learn how our refunds work" --cap 1');
+    return 1;
+  }
+  const capCheck = parseCap(flags.cap);
+  if (!capCheck.ok) {
+    err('The cap must be more than $0. Example: --cap 1');
+    return 1;
+  }
+
+  const load = deps.loadCredentials || require('../utils/auth').loadCredentials;
+  const request = deps.apiRequestJson || require('../utils/api').apiRequestJson;
+  const creds = await load(request);
+  const token = creds && typeof creds.token === 'string' ? creds.token.trim() : '';
+  if (!token) {
+    err(NOT_LOGGED_IN);
+    return 1;
+  }
+
+  const { agentId, businessId } = resolveTarget(flags, creds, deps);
+  const body = { goal, cap_usd: capCheck.cap };
+  if (agentId) body.agent_id = agentId;
+  if (businessId) body.business_id = businessId;
+
+  const result = await request('/night-shift', { method: 'POST', token, body, retries: 0 });
+  if (!result || !result.ok) {
+    err(`Could not start the night shift: ${errorText(result)}`);
+    return 1;
+  }
+  const data = result.data || {};
+  if (!data.shift_id) {
+    err('Atris did not return a shift id, so the shift may not have started.');
+    return 1;
+  }
+
+  log(`Night shift starts at ${formatStart(data.starts_at, deps.now ? deps.now() : new Date())} with a ${formatUsd(capCheck.cap)} cap. Shift ${data.shift_id}.`);
+
+  if (!flags.watch) return 0;
+  return watchShift(data.shift_id, {
+    request,
+    token,
+    log,
+    err,
+    sleep: deps.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    pollMs: deps.pollMs != null ? deps.pollMs : POLL_MS,
+  });
+}
+
+module.exports = { nightCommand, showNightHelp, parseCap, formatStart, eventLine };

package/commands/recap.js

@@ -312,8 +312,8 @@ function renderRecapMinute(data, { person } = {}) {
   if (shipped.length) {
     const named = recapSoftTitle(shipped[0].title);
     return named
-      ? `${greet}you already shipped ${named}.`
-      : `${greet}you already shipped the last finished thing.`;
+      ? `${greet}you already finished ${named}.`
+      : `${greet}you already finished the last piece of work.`;
   }
 
   if (inProgress.length) {
@@ -321,12 +321,12 @@ function renderRecapMinute(data, { person } = {}) {
     const named = recapSoftTitle(item && item.title);
     if (item && item.owner && named) {
       return [
-        `${greet}${named} is already yours.`,
+        `${greet}you are working on ${named}.`,
         '',
         `next: ${taskCommand({ display_id: item.id, status: 'claimed' })}`,
       ].join('\n');
     }
-    if (named) return `${greet}${named} is ready to claim.`;
+    if (named) return `${greet}${named} is ready to start.`;
   }
 
   return `${greet}quiet window. nothing moved in this period.`;

package/commands/task.js

@@ -6340,13 +6340,42 @@ function cmdTag(args) {
   if (!id) failTask('atris task tag', 'missing_id', 'task id required');
   const add = collectFlagValues(args, '--add');
   const remove = collectFlagValues(args, '--remove');
-  if (!add.length && !remove.length) {
-    failTask('atris task tag', 'missing_tags', 'at least one --add <tag> or --remove <tag> required');
+  const setTag = pos.slice(1).join(' ').trim();
+  if (!add.length && !remove.length && !setTag) {
+    failTask('atris task tag', 'missing_tags', 'a tag, or at least one --add <tag> or --remove <tag>, required');
+  }
+  if (setTag && (add.length || remove.length)) {
+    failTask('atris task tag', 'tag_conflict', 'use either `task tag <id> <tag>` or --add/--remove, not both');
   }
   const actor = flag(args, '--as') || DEFAULT_OWNER;
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const taskId = requireTaskId(taskDb, db, id, 'atris task tag');
+  if (setTag) {
+    // Sets the primary tag, the same field `task add --tag` writes at creation.
+    const set = taskDb.setTaskTag(db, { id: taskId, actor: String(actor), tag: setTag });
+    if (!set.tagged && set.reason !== 'no_changes') {
+      failTask('atris task tag', set.reason || 'tag_failed', `tag failed: ${set.reason || 'unknown'}`, 1);
+    }
+    const { projection, outPath } = writeDefaultProjection(taskDb, db);
+    const task = compactTaskFromProjection(projection, taskId);
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: set.tagged ? 'tag_set' : 'unchanged',
+        task_id: taskId,
+        tag: set.tag,
+        previous_tag: set.tagged ? set.previous_tag : set.tag,
+        projection_path: outPath,
+        task,
+      });
+      return;
+    }
+    console.log(set.tagged
+      ? `tagged ${taskRef(task)} tag ${set.previous_tag || 'none'} -> ${set.tag}`
+      : `no change ${taskRef(task)} tag ${set.tag}`);
+    return;
+  }
   const result = taskDb.tagTask(db, { id: taskId, actor: String(actor), add, remove });
   if (!result.tagged) {
     if (result.reason === 'no_changes') {