atris 3.34.0 → 3.36.0

package/commands/activate.js

@@ -3,6 +3,148 @@ const path = require('path');
 const { getLogPath, ensureLogDirectory, createLogFile } = require('../lib/journal');
 const { detectWorkspaceState, loadContext } = require('../lib/state-detection');
 const { readWikiStatus } = require('../lib/wiki');
+const { gateForHuman, numberWord } = require('../lib/voice-gate');
+
+const CLARITY_FIELDS = [
+  { key: 'focus', label: 'Focus' },
+  { key: 'voice', label: 'Voice' },
+  { key: 'cadence', label: 'Cadence' },
+  { key: 'done', label: 'Done means' },
+  { key: 'leash', label: 'Leash' },
+];
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function readClarityMarkdownProfile(mdPath) {
+  try {
+    const content = fs.readFileSync(mdPath, 'utf8');
+    const profile = {};
+    for (const { key, label } of CLARITY_FIELDS) {
+      const match = content.match(new RegExp(`^- ${escapeRegExp(label)}: (.+)$`, 'm'));
+      if (match?.[1]?.trim()) profile[key] = match[1].trim();
+    }
+    return profile;
+  } catch {
+    return {};
+  }
+}
+
+function readActivationClarityProfile(root, profilePaths) {
+  const paths = profilePaths(root);
+  if (fs.existsSync(paths.json)) {
+    try {
+      return { profile: JSON.parse(fs.readFileSync(paths.json, 'utf8')), mdPath: paths.md };
+    } catch {
+      return { profile: {}, mdPath: paths.md };
+    }
+  }
+  if (fs.existsSync(paths.md)) {
+    return { profile: readClarityMarkdownProfile(paths.md), mdPath: paths.md };
+  }
+  return { profile: {}, mdPath: paths.md };
+}
+
+function formatClarityLine(profile, mdRelPath) {
+  const parts = CLARITY_FIELDS
+    .map(({ key }) => (profile?.[key] ? `${key} ${profile[key]}` : null))
+    .filter(Boolean);
+  if (!parts.length) return null;
+  return `clarity: ${parts.join(', ')} (see ${mdRelPath})`;
+}
+
+function countWord(value) {
+  const count = Math.max(0, Math.trunc(Number(value) || 0));
+  return numberWord(count);
+}
+
+function sentenceFragment(value) {
+  return String(value || '')
+    .replace(/[`*_#>]+/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/[.!?]+$/, '');
+}
+
+function humanSentence(value) {
+  return gateForHuman(value).text.toLowerCase();
+}
+
+// Titles arrive with tracker tags and stacked clauses; the narration keeps
+// one readable clause so the operator can take it in at a glance.
+function focusFragment(value, max = 72) {
+  const first = sentenceFragment(value)
+    .replace(/\[[^\]]*\]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .split(';')[0]
+    .trim();
+  if (first.length <= max) return first;
+  const cut = first.slice(0, max);
+  return `${cut.slice(0, cut.lastIndexOf(' '))}...`;
+}
+
+// A truncated fragment already ends with '...'; adding the template's period
+// would render four dots.
+function closeSentence(fragment) {
+  return fragment.endsWith('...') ? fragment : `${fragment}.`;
+}
+
+// The handoff block is markdown for agents; the operator gets its context
+// line as one plain sentence.
+function handoffSentence(handoffContent) {
+  if (!handoffContent) return null;
+  const contextMatch = String(handoffContent).match(/\*\*Context:\*\*\s*(.+)/);
+  const note = focusFragment(contextMatch?.[1] || handoffContent, 100);
+  if (!note) return null;
+  return humanSentence(`last session left a note: ${closeSentence(note)}`);
+}
+
+function completionSentence(completions) {
+  if (!Array.isArray(completions) || !completions.length) return null;
+  const count = completions.length;
+  const biggest = sentenceFragment(completions[0]?.desc);
+  if (!biggest) return null;
+  const landed = count === 1 ? 'one thing landed' : `${countWord(count)} things landed`;
+  return humanSentence(`since last time: ${landed}; the biggest: ${biggest}.`);
+}
+
+function activeWorkSentence(state, context) {
+  const tasks = Array.isArray(context?.inProgressTasks) ? context.inProgressTasks : [];
+  if (tasks.length) {
+    const count = tasks.length;
+    const focus = focusFragment(tasks[0]);
+    const subject = count === 1 ? 'task is' : 'tasks are';
+    return humanSentence(`right now: ${countWord(count)} ${subject} in progress; the focus is ${closeSentence(focus)}`);
+  }
+
+  const features = Array.isArray(context?.inProgressFeatures) ? context.inProgressFeatures : [];
+  const featureCount = Number(context?.inProgressFeaturesCount) || features.length;
+  if (featureCount > 0 && features.length) {
+    const focus = focusFragment(features[0]).replace(/[-_]+/g, ' ');
+    const subject = featureCount === 1 ? 'feature is' : 'features are';
+    return humanSentence(`right now: ${countWord(featureCount)} ${subject} in progress; the focus is ${closeSentence(focus)}`);
+  }
+
+  const inboxCount = Number(context?.inboxCount) || 0;
+  const inboxItem = sentenceFragment(context?.inboxItems?.[0]);
+  if (inboxCount > 0 && inboxItem) {
+    const subject = inboxCount === 1 ? 'inbox item is' : 'inbox items are';
+    return humanSentence(`right now: ${countWord(inboxCount)} ${subject} waiting; first: ${closeSentence(inboxItem)}`);
+  }
+
+  if (state?.state === 'blocked' && state.reason) {
+    return humanSentence(`right now: work is blocked by ${sentenceFragment(state.reason)}.`);
+  }
+  if (state?.state === 'ready') {
+    return humanSentence('right now: no active work is in progress.');
+  }
+  if (state?.state) {
+    return humanSentence(`right now: the workspace is ${sentenceFragment(state.state)}.`);
+  }
+  return null;
+}
 
 function activateAtris() {
   const workspaceDir = process.cwd();
@@ -56,7 +198,7 @@ function activateAtris() {
     allLogs.sort().reverse();
 
     // Extract C# items from logs until we have 3. Dedupe by ID across files
-    // since per-day numbering reuses C1, C2, etc. — the same ID appearing
+    // since per-day numbering reuses C1, C2, etc. the same ID appearing
     // in two day-files would otherwise render as duplicate rows.
     const seenIds = new Set();
     for (const logPath of allLogs) {
@@ -65,7 +207,7 @@ function activateAtris() {
       const completedSection = content.match(/## Completed ✅\n([\s\S]*?)(?=\n## |$)/);
       if (completedSection) {
         // Match `- **C#: Title**` (title between the bold markers). If extra
-        // prose follows after `**`, ignore it — the activation panel shows
+        // prose follows after `**`, ignore it. the activation view shows
         // titles only, truncated to 59 chars.
         const matches = completedSection[1].matchAll(/- \*\*C(\d+):\s*([^*\n]+?)\*\*/gm);
         for (const match of matches) {
@@ -84,106 +226,70 @@ function activateAtris() {
     ? todoFile
     : (fs.existsSync(legacyTaskContextsFile) ? legacyTaskContextsFile : null);
 
-  const summaryParts = [];
-  if (context.inProgressFeatures?.length) summaryParts.push(`⚡ ${context.inProgressFeatures.length} in progress`);
-  if (context.backlogTasks?.length) summaryParts.push(`📋 ${context.backlogTasks.length} backlog`);
-  if (context.inboxItems?.length) summaryParts.push(`📥 ${context.inboxItems.length} inbox`);
-  const summaryLine = summaryParts.length ? summaryParts.join('  |  ') : 'Clean slate';
-
-  console.log('');
-  console.log('┌─────────────────────────────────────────────────────────────┐');
-  console.log('│ Atris Activate — Context Loaded                             │');
-  console.log('└─────────────────────────────────────────────────────────────┘');
-
-  // Display handoff prominently if present
-  if (handoffContent) {
-    console.log('');
-    console.log('┌─────────────────────────────────────────────────────────────┐');
-    console.log('│ 📋 HANDOFF FROM LAST SESSION                                │');
-    console.log('├─────────────────────────────────────────────────────────────┤');
-    const lines = handoffContent.split('\n').slice(0, 5); // Max 5 lines
-    lines.forEach(line => {
-      const padded = line.substring(0, 59).padEnd(59);
-      console.log(`│ ${padded} │`);
-    });
-    console.log('└─────────────────────────────────────────────────────────────┘');
-  }
-
-  // Display recent completions if any
-  if (recentCompletions.length > 0) {
-    console.log('');
-    console.log('┌─────────────────────────────────────────────────────────────┐');
-    console.log('│ ✅ RECENT COMPLETIONS                                       │');
-    console.log('├─────────────────────────────────────────────────────────────┤');
-    recentCompletions.forEach(c => {
-      const line = `${c.id}: ${c.desc}`;
-      const padded = line.substring(0, 59).padEnd(59);
-      console.log(`│ ${padded} │`);
-    });
-    console.log('└─────────────────────────────────────────────────────────────┘');
-  }
-
-  // Show learning count if learnings exist
-  let learningLine = '';
+  // Keep loading learnings for parity with the existing activation path.
+  let learningCount = 0;
   try {
     const learningsPath = path.join(targetDir, 'learnings.jsonl');
     if (fs.existsSync(learningsPath)) {
       const lines = fs.readFileSync(learningsPath, 'utf8').trim().split('\n').filter(Boolean);
-      if (lines.length > 0) {
-        learningLine = `  •  🧠 ${lines.length} learnings`;
-      }
+      learningCount = lines.length;
     }
   } catch {}
 
-  console.log('');
-  console.log(`📅 ${dateFormatted}  •  State: ${state.state}${learningLine}`);
-  console.log(`   ${summaryLine}`);
-  if (wikiStatus) {
-    const healthLine = wikiStatus.bullets.find((line) => line.startsWith('- Health:'));
-    const wikiSummary = (healthLine || wikiStatus.bullets[0] || '- wiki scaffold ready').replace(/^- /, '');
-    console.log(`   🧠 Wiki: ${wikiSummary}`);
-  }
-  console.log('');
-  console.log('Core files:');
-  console.log(`- ${fs.existsSync(personaFile) ? rel(personaFile) : 'atris/PERSONA.md (missing)'}`);
-  console.log(`- ${fs.existsSync(mapFile) ? rel(mapFile) : 'atris/MAP.md (missing)'}`);
-  console.log(`- ${taskFilePath ? rel(taskFilePath) : 'atris/TODO.md (missing)'}`);
-  console.log(`- ${rel(logFile)}`);
-  if (wikiStatus?.statusPath) {
-    console.log(`- ${rel(wikiStatus.statusPath)}`);
-  }
-  if (wikiStatus?.bullets?.length) {
-    console.log('');
-    console.log('Wiki:');
-    wikiStatus.bullets.forEach((line) => console.log(`- ${line.replace(/^- /, '')}`));
-  }
-  console.log('');
+  let moves = [];
   try {
     const { nextMoves } = require('../lib/next-moves');
-    const { readProfile, isEmptyProfile } = require('../lib/clarity');
+    const { profilePaths } = require('../lib/clarity');
     const root = process.cwd();
-    const moves = nextMoves(root, 3);
-    console.log('Your next moves:');
-    if (moves.length) {
-      moves.forEach((m, i) => console.log(`  ${i + 1}. ${m.title}`));
-      console.log('  steer them: atris moves');
+    moves = nextMoves(root, 3);
+    const { profile, mdPath } = readActivationClarityProfile(root, profilePaths);
+    formatClarityLine(profile, rel(mdPath));
+  } catch { /* alive onboarding is best-effort; never block activate */ }
+
+  let briefData = null;
+  try {
+    const { buildBriefData } = require('./brief');
+    briefData = buildBriefData(workspaceDir);
+  } catch { /* brief is best-effort */ }
+  try {
+    const { syncStatus } = require('../lib/sync-status');
+    syncStatus(workspaceDir);
+  } catch { /* sync status is best-effort */ }
+
+  void dateFormatted;
+  void learningCount;
+  void wikiStatus;
+  fs.existsSync(personaFile);
+  fs.existsSync(mapFile);
+  void taskFilePath;
+
+  console.log(humanSentence('atris is up.'));
+
+  const statusLines = [
+    handoffSentence(handoffContent),
+    completionSentence(recentCompletions),
+    activeWorkSentence(state, context),
+  ].filter(Boolean);
+  if (Array.isArray(briefData?.waiting)) {
+    const approvalCount = briefData.waiting.length;
+    if (approvalCount === 0) {
+      statusLines.push('nothing is waiting on you.');
     } else {
-      console.log('  none queued. add to ROADMAP.md under "## Open loop items", or jot one with atris log');
+      const approvalLabel = approvalCount === 1 ? 'approval' : 'approvals';
+      statusLines.push(`waiting on you: ${countWord(approvalCount)} ${approvalLabel}. see them: atris task reviews`);
     }
-    const profile = readProfile(root);
+  }
+  if (statusLines.length) {
     console.log('');
-    if (isEmptyProfile(profile)) {
-      console.log('Tip: run atris clarity once so agents learn how you work.');
-    } else {
-      console.log('How you work (atris clarity):');
-      ['focus', 'voice', 'cadence', 'done', 'leash']
-        .filter((k) => profile[k])
-        .forEach((k) => console.log(`  ${k}: ${profile[k]}`));
-    }
+    statusLines.forEach((line) => console.log(line));
+  }
+
+  const nextMove = moves[0] || briefData?.moves?.[0];
+  const nextMoveTitle = focusFragment(nextMove?.title, 100);
+  if (nextMoveTitle) {
     console.log('');
-  } catch { /* alive onboarding is best-effort; never block activate */ }
-  console.log('Next: atris plan → do → review (or atris log)');
-  console.log('');
+    console.log(humanSentence(`today's move: ${closeSentence(nextMoveTitle)}`));
+  }
 }
 
 module.exports = { activateAtris };

package/commands/aeo.js

@@ -157,6 +157,9 @@ function pickSlug(args) {
 
 function printHelp() {
   console.log('Usage:');
+  console.log('  Live scan (no login needed):');
+  console.log('    atris aeo scan <url> [--vs <competitor-url>] [--json]');
+  console.log('');
   console.log('  Backend / EC2:');
   console.log('    atris aeo init   [--workspace <slug>]');
   console.log('    atris aeo draft  "<topic>" [--workspace <slug>] [--queries q1,q2] [--slug X] [--url URL]');
@@ -178,6 +181,54 @@ function printHelp() {
   console.log('  atris aeo discover https://atris.ai/aeo --canonical-url https://atris.ai/aeo');
 }
 
+const FREE_SCAN_BASE = process.env.ATRIS_API_BASE || 'https://api.atris.ai';
+
+async function aeoScan(args) {
+  const asJson = args.includes('--json');
+  const vs = readArg(args, '--vs');
+  const url = args.filter((a) => !a.startsWith('--') && a !== vs)[0];
+  if (!url) {
+    console.error('Usage: atris aeo scan <url> [--vs <competitor-url>] [--json]');
+    process.exit(1);
+  }
+  const target = /^https?:\/\//i.test(url) ? url : `https://${url}`;
+  const qs = new URLSearchParams({ url: target });
+  if (vs) qs.set('vs', /^https?:\/\//i.test(vs) ? vs : `https://${vs}`);
+  const endpoint = `${FREE_SCAN_BASE}/api/business/aeo/free-scan?${qs}`;
+  let data;
+  try {
+    const res = await fetch(endpoint, { signal: AbortSignal.timeout(60000) });
+    if (!res.ok) {
+      const body = await res.text().catch(() => '');
+      console.error(`Scan failed (${res.status}): ${body.slice(0, 200)}`);
+      process.exit(1);
+    }
+    data = await res.json();
+  } catch (e) {
+    console.error(`Scan failed: ${e.message}`);
+    process.exit(1);
+  }
+  if (asJson) { console.log(JSON.stringify(data, null, 2)); return; }
+  console.log(`\n  ${data.name || target}`);
+  console.log(`  Score: ${data.score}/100 (${data.grade}) — ${data.status}`);
+  if (data.gap_statement) console.log(`\n  ${data.gap_statement}`);
+  const gaps = data.gaps || [];
+  if (gaps.length) {
+    console.log('\n  Gaps:');
+    for (const g of gaps) console.log(`   ✗ ${g.title || g.key}: ${g.fix || ''}`);
+  }
+  const comp = data.competitors || [];
+  if (comp.length) {
+    console.log('\n  Head-to-head:');
+    for (const c of comp) console.log(`   ${pad(String(c.score ?? '?'), 4)} ${c.url || c.name}`);
+  }
+  if (data.draft_llms_txt) {
+    console.log('\n  Draft llms.txt included — save it with:');
+    console.log(`   atris aeo scan ${url} --json | jq -r .draft_llms_txt > llms.txt`);
+  }
+  console.log('');
+}
+
 async function aeoInit(args) {
   const slug = pickSlug(args);
   if (!slug) {
@@ -545,6 +596,7 @@ async function run(args = []) {
   const sub = args[0];
   if (!sub || sub === 'help' || sub === '--help' || sub === '-h') return printHelp();
   const rest = args.slice(1);
+  if (sub === 'scan') return aeoScan(rest);
   if (sub === 'init') return aeoInit(rest);
   if (sub === 'draft') return aeoDraft(rest);
   if (sub === 'log') return aeoLog(rest);

package/commands/agents.js

@@ -0,0 +1,166 @@
+'use strict';
+
+// atris agents — one glanceable view of every member's state.
+// Reads .atris/state/missions.jsonl (schema atris.mission.v1) plus the
+// directories in atris/team/, and prints who is stuck, waiting on you,
+// working, or resting. Built from a dream card: "validator cannot plan
+// missions without seeing which agents are idle or blocked."
+
+const fs = require('fs');
+const path = require('path');
+const { listMissions } = require('./mission');
+const { normalizeOwnerSlug } = require('../lib/functional-owner');
+const { shortRecordLabel } = require('../lib/short-name');
+
+const WORKING_STATUSES = new Set(['running', 'planning']);
+const STUCK_STATUSES = new Set(['blocked', 'stuck', 'failed']);
+const RESTING_STATUSES = new Set(['complete', 'stopped', 'paused']);
+
+const STATE_RANK = {
+  stuck: 0,
+  'waiting on you': 1,
+  working: 2,
+  resting: 3,
+  idle: 4,
+};
+
+function listTeamDirs(root) {
+  const teamDir = path.join(root, 'atris', 'team');
+  try {
+    return fs.readdirSync(teamDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .filter((name) => name !== '_template' && !name.startsWith('.'));
+  } catch {
+    return [];
+  }
+}
+
+// Given a member's missions (already newest-first), pick one state word.
+// Priority: a stuck mission always wins (that is the whole point of this
+// view). Otherwise, if the newest mission is ready, they are waiting on a
+// human. Otherwise, any running/planning mission means they are working.
+// Anything left over (complete/stopped/paused, or nothing at all) rests.
+function ownerState(missions) {
+  if (!missions.length) return { state: 'idle', current: null };
+  const stuckMission = missions.find((m) => STUCK_STATUSES.has(m.status));
+  if (stuckMission) return { state: 'stuck', current: stuckMission };
+  const latest = missions[0];
+  if (latest.status === 'ready') return { state: 'waiting on you', current: latest };
+  const workingMission = missions.find((m) => WORKING_STATUSES.has(m.status));
+  if (workingMission) return { state: 'working', current: workingMission };
+  const restingMission = missions.find((m) => RESTING_STATUSES.has(m.status)) || latest;
+  return { state: 'resting', current: restingMission };
+}
+
+function missionLabel(mission) {
+  if (!mission) return null;
+  return shortRecordLabel(mission, mission.objective || mission.slug || mission.id, { wordLimit: 4 });
+}
+
+// Build one row per member: team directories plus anyone who owns a
+// mission but has no directory yet. Returns rows sorted stuck first, then
+// waiting on you, then working, then resting/idle.
+function buildAgentRows(root = process.cwd()) {
+  const missions = listMissions(root);
+  const displayNames = new Map(); // normalized slug -> name to print
+  const missionsByOwner = new Map(); // normalized slug -> missions (newest-first)
+
+  for (const name of listTeamDirs(root)) {
+    const slug = normalizeOwnerSlug(name);
+    if (!slug) continue;
+    if (!displayNames.has(slug)) displayNames.set(slug, name);
+    if (!missionsByOwner.has(slug)) missionsByOwner.set(slug, []);
+  }
+
+  for (const mission of missions) {
+    const raw = String(mission.owner || '').trim();
+    if (!raw) continue;
+    const slug = normalizeOwnerSlug(raw);
+    if (!slug) continue;
+    if (!displayNames.has(slug)) displayNames.set(slug, raw);
+    if (!missionsByOwner.has(slug)) missionsByOwner.set(slug, []);
+    missionsByOwner.get(slug).push(mission);
+  }
+
+  const rows = [];
+  for (const [slug, ownerMissions] of missionsByOwner.entries()) {
+    const { state, current } = ownerState(ownerMissions);
+    rows.push({
+      owner: displayNames.get(slug) || slug,
+      state,
+      label: missionLabel(current),
+    });
+  }
+
+  rows.sort((a, b) => {
+    const rankDiff = STATE_RANK[a.state] - STATE_RANK[b.state];
+    if (rankDiff !== 0) return rankDiff;
+    return a.owner.localeCompare(b.owner);
+  });
+
+  return rows;
+}
+
+function formatRow(row) {
+  return row.label ? `${row.owner} - ${row.state} - ${row.label}` : `${row.owner} - ${row.state}`;
+}
+
+// Split rows into the always-shown head (stuck, waiting on you, working)
+// and the foldable tail (resting, idle). When `all` is false, the tail
+// collapses into a single count line so a big roster stays glanceable.
+function renderAgentLines(rows, { all = false } = {}) {
+  const head = [];
+  const tail = [];
+  for (const row of rows) {
+    if (row.state === 'resting' || row.state === 'idle') tail.push(row);
+    else head.push(row);
+  }
+
+  const lines = head.map(formatRow);
+  if (all) {
+    lines.push(...tail.map(formatRow));
+  } else if (tail.length) {
+    const noun = tail.length === 1 ? 'member' : 'members';
+    lines.push(`${tail.length} ${noun} resting or idle. See them with atris agents --all`);
+  }
+
+  if (!lines.length) lines.push('No agents found. Add someone to atris/team or start a mission.');
+  return lines;
+}
+
+function printHelp() {
+  console.log('Usage: atris agents [--all] [--json]');
+  console.log('Shows every member: stuck, waiting on you, working, or resting.');
+}
+
+function agentsCommand(args = [], { root = process.cwd() } = {}) {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    return 0;
+  }
+  const all = args.includes('--all');
+  const rows = buildAgentRows(root);
+
+  if (args.includes('--json')) {
+    console.log(JSON.stringify({
+      schema: 'atris.agents.v1',
+      all,
+      agents: rows,
+    }));
+    return 0;
+  }
+
+  for (const line of renderAgentLines(rows, { all })) {
+    console.log(line);
+  }
+  return 0;
+}
+
+module.exports = {
+  agentsCommand,
+  buildAgentRows,
+  renderAgentLines,
+  ownerState,
+  missionLabel,
+};