atris 3.56.0 → 3.56.2

package/lib/first-minute.js

@@ -3,10 +3,13 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { spawnSync } = require('child_process');
 const { isGenericScratchRoot } = require('./scratch-root');
 
 const FIRST_USE_COMMAND = 'atris "help me choose the first useful step for this project"';
-const INIT_COMMAND = 'atris init --minimal';
+const FIRST_TALK_ASK = 'what do you want here';
+const CLAIMED_KEEP_WORKING_VERIFY = 'git diff --check';
+const LATER_NOTE_FILE = '.atris-later';
 const BARE_ATRIS_FLAGS = new Set(['--yes', '-y', '--json', '--verbose']);
 const NOT_A_PERSON = new Set([
   'root', 'node', 'ubuntu', 'admin', 'nobody', 'www', 'daemon', 'guest',
@@ -102,6 +105,31 @@ function greet(person) {
   return person ? `hey ${person}, ` : '';
 }
 
+function firstTalkCommand(_folder = 'this folder') {
+  return `atris "${FIRST_TALK_ASK}?"`;
+}
+
+function isFirstTalkLine(value) {
+  const text = String(value || '')
+    .trim()
+    .replace(/^atris\s+/i, '')
+    .replace(/^["']+|["']+$/g, '')
+    .toLowerCase()
+    .replace(/[?.!]+$/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return text === FIRST_TALK_ASK;
+}
+
+function hasLiveWork({
+  task = null,
+  backlogCount = 0,
+  wipCount = 0,
+  inboxCount = 0,
+} = {}) {
+  return Boolean(task || backlogCount > 0 || wipCount > 0 || inboxCount > 0);
+}
+
 function softTitle(title, maxWords = 5) {
   const words = String(title || '').replace(/\s+/g, ' ').trim().split(' ').filter(Boolean);
   if (!words.length) return '';
@@ -128,23 +156,50 @@ function isCertifiedReview(task) {
   return Number(review.agent_review_pass_count || metadata.agent_review_pass_count || 0) >= 2;
 }
 
+function isActionableTask(task) {
+  const status = task && task.status;
+  return status === 'open' || status === 'claimed' || status === 'review';
+}
+
+function titlesFromTodoSection(root, section) {
+  try {
+    const text = fs.readFileSync(path.join(root, 'atris', 'TODO.md'), 'utf8');
+    const match = String(text).match(new RegExp(`##\\s+${section}\\n([\\s\\S]*?)(?=\\n##|$)`, 'i'));
+    if (!match) return null;
+    const body = String(match[1] || '').trim();
+    if (!body || /\(empty|\(see /i.test(body)) return [];
+    return body
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => /^-\s+/.test(line) && !/\(empty/i.test(line))
+      .map((line) => line.replace(/^-+\s*/, '').trim())
+      .filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
 function loadLocalTasks(root = process.cwd()) {
+  let dbRows = [];
   try {
     const taskDb = require('./task-db');
     const db = taskDb.open();
     const workspaceRoot = taskDb.workspaceRoot(root);
     const rows = taskDb.listTasks(db, { workspaceRoot, limit: 200 });
-    if (Array.isArray(rows) && rows.length) return taskDb.withTaskDisplayRefs(rows);
+    if (Array.isArray(rows) && rows.length) dbRows = taskDb.withTaskDisplayRefs(rows);
   } catch {
     // Fall through to the local projection. Tests and fresh folders often have no db.
   }
+  if (dbRows.some(isActionableTask)) return dbRows;
   const projectionPath = path.join(root, '.atris', 'state', 'tasks.projection.json');
   try {
     const parsed = JSON.parse(fs.readFileSync(projectionPath, 'utf8'));
-    return Array.isArray(parsed.tasks) ? parsed.tasks : [];
+    const projected = Array.isArray(parsed.tasks) ? parsed.tasks : [];
+    if (projected.some(isActionableTask) || !dbRows.length) return projected;
   } catch {
-    return [];
+    // Keep any done-only db rows below.
   }
+  return dbRows;
 }
 
 function loadLatestRecap(root = process.cwd()) {
@@ -183,15 +238,25 @@ function loadLatestRecap(root = process.cwd()) {
   return title ? { title, file: hit.file } : null;
 }
 
+function claimedKeepWorkingCommand(task) {
+  const ref = taskRef(task);
+  return ref
+    ? `atris task ready ${ref} --verify "${CLAIMED_KEEP_WORKING_VERIFY}"`
+    : `atris task ready --verify "${CLAIMED_KEEP_WORKING_VERIFY}"`;
+}
+
+function isClaimedKeepWorkingCommand(command) {
+  return /^atris task ready\b/.test(String(command || ''));
+}
+
 function taskCommand(task, person) {
   const ref = taskRef(task);
   const who = person || 'operator';
   if (!task) return FIRST_USE_COMMAND;
   if (task.status === 'review') {
-    if (isCertifiedReview(task)) return ref ? `atris task accept ${ref}` : 'atris task reviews --limit 5';
-    return ref ? `atris task review-chat ${ref} --as codex-review` : 'atris task reviews --limit 5';
+    return ref ? `atris task accept ${ref}` : 'atris task reviews --limit 5';
   }
-  if (task.status === 'claimed') return ref ? `atris task ready ${ref}` : 'atris do';
+  if (task.status === 'claimed') return claimedKeepWorkingCommand(task);
   if (task.status === 'open') {
     return ref ? `atris task claim ${ref} --as ${who}` : 'atris task next';
   }
@@ -246,22 +311,342 @@ function pickNext({
   return { command: FIRST_USE_COMMAND };
 }
 
-function renderFresh({ person = '', folder = 'this folder' } = {}) {
+function isUserVisibleName(name) {
+  const text = String(name || '');
+  if (!text || text === '.' || text === '..') return false;
+  if (text.startsWith('.')) return false;
+  // The local task store can land in the folder during a look.
+  // It is system noise, not user work.
+  return !/^tasks\.db(-wal|-shm)?$/i.test(text);
+}
+
+function directoryHasUserVisibleWork(dir) {
+  let names = [];
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return false;
+  }
+  return names.some(isUserVisibleName);
+}
+
+function isUserVisibleWorkEntry(root, name) {
+  if (!isUserVisibleName(name)) return false;
+  const full = path.join(root, name);
+  let stat;
+  try {
+    stat = fs.lstatSync(full);
+  } catch {
+    return false;
+  }
+  if (stat.isDirectory()) return directoryHasUserVisibleWork(full);
+  return true;
+}
+
+function listUserVisibleWork(root = process.cwd()) {
+  let names = [];
+  try {
+    names = fs.readdirSync(root);
+  } catch {
+    return [];
+  }
+  return names.filter((name) => isUserVisibleWorkEntry(root, name))
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function spokenVisibleNames(files) {
+  const seen = new Set();
+  const names = [];
+  for (const raw of Array.isArray(files) ? files : []) {
+    const name = path.basename(String(raw || '')).replace(/\s+/g, ' ').trim();
+    if (!isUserVisibleName(name) || seen.has(name)) continue;
+    seen.add(name);
+    names.push(name);
+  }
+  return names.sort((a, b) => a.localeCompare(b));
+}
+
+function spokenCommitSubject(value) {
+  const text = clip(value, 72);
+  if (text.endsWith('...')) return text;
+  return text.replace(/[.,;:!?]+$/g, '');
+}
+
+function spokenBranchName(value) {
+  let text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  if (/^origin\//.test(text)) text = text.slice('origin/'.length).replace(/\s+/g, ' ').trim();
+  if (!text || text === 'HEAD') return '';
+  if (/^(main|master)$/i.test(text)) return '';
+  if (/^[0-9a-f]{7,}$/i.test(text)) return '';
+  return clip(text, 72);
+}
+
+function gitProbeEnv() {
+  const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_INDEX_FILE;
+  return env;
+}
+
+function hasLocalGit(root = process.cwd()) {
+  try {
+    return fs.existsSync(path.join(path.resolve(root || '.'), '.git'));
+  } catch {
+    return false;
+  }
+}
+
+function gitProbe(root, args) {
+  return spawnSync('git', [
+    '-C', path.resolve(root || '.'),
+    '-c', 'safe.directory=*',
+    ...args,
+  ], {
+    encoding: 'utf8',
+    timeout: 3000,
+    stdio: ['ignore', 'pipe', 'ignore'],
+    env: gitProbeEnv(),
+  });
+}
+
+function porcelainPath(line) {
+  const text = String(line || '');
+  if (text.length < 4) return '';
+  let body = text.slice(3);
+  if (/^[CR]/.test(text)) {
+    const arrow = body.lastIndexOf(' -> ');
+    if (arrow >= 0) body = body.slice(arrow + 4);
+  }
+  const trimmed = body.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+  }
+  return trimmed;
+}
+
+function listDirtyWork(root = process.cwd()) {
+  if (!hasLocalGit(root)) return null;
+  try {
+    const result = gitProbe(root, ['status', '--porcelain']);
+    if (!result || result.status !== 0) return null;
+    const names = String(result.stdout || '')
+      .split('\n')
+      .map(porcelainPath)
+      .filter(Boolean);
+    return names.length ? names : null;
+  } catch {
+    return null;
+  }
+}
+
+function spokenOpenWork(files) {
+  const names = spokenVisibleNames(files);
+  if (names.length === 1) return `${names[0]} is still open.`;
+  if (names.length === 2) return `${names[0]} and ${names[1]} are still open.`;
+  return 'this folder still has open work.';
+}
+
+function headCommitSubject(root = process.cwd()) {
+  if (!hasLocalGit(root)) return '';
+  try {
+    const result = gitProbe(root, [
+      '-c', 'log.showSignature=false',
+      'log', '-1', '--pretty=format:%s',
+    ]);
+    if (!result || result.status !== 0) return '';
+    return spokenCommitSubject(result.stdout);
+  } catch {
+    return '';
+  }
+}
+
+function headBranchName(root = process.cwd()) {
+  if (!hasLocalGit(root)) return '';
+  try {
+    const result = gitProbe(root, ['branch', '--show-current']);
+    if (!result || result.status !== 0) return '';
+    return spokenBranchName(result.stdout);
+  } catch {
+    return '';
+  }
+}
+
+function resolveFreshCommit({ root, files, commit } = {}) {
+  const visible = spokenVisibleNames(files);
+  if (!visible.length) return '';
+  if (commit !== undefined) return spokenCommitSubject(commit);
+  return root ? headCommitSubject(root) : '';
+}
+
+function resolveFreshBranch({ root, files, commit, branch } = {}) {
+  const visible = spokenVisibleNames(files);
+  if (!visible.length) return '';
+  if (branch !== undefined) return spokenBranchName(branch);
+  if (commit !== undefined) return '';
+  return root ? headBranchName(root) : '';
+}
+
+function resolveFreshOpenWork({ root, files, commit, dirty } = {}) {
+  const visible = spokenVisibleNames(files);
+  if (!visible.length) return '';
+  if (dirty !== undefined) {
+    const names = spokenVisibleNames(Array.isArray(dirty) ? dirty : []);
+    if (!names.length) return '';
+    return spokenOpenWork(names);
+  }
+  if (commit !== undefined) return '';
+  if (!root) return '';
+  if (!headCommitSubject(root)) return '';
+  const listed = listDirtyWork(root);
+  if (!listed) return '';
+  const names = spokenVisibleNames(listed);
+  if (!names.length) return '';
+  return spokenOpenWork(names);
+}
+
+function laterNotePath(root = process.cwd()) {
+  return path.join(path.resolve(root || '.'), LATER_NOTE_FILE);
+}
+
+function spokenLaterNote(value) {
+  const text = clip(String(value || '').replace(/\s+/g, ' ').trim(), 72);
+  if (!text) return '';
+  if (text.endsWith('...')) return text;
+  return text.replace(/[.,;:!?]+$/g, '');
+}
+
+function readLaterNote(root = process.cwd()) {
+  try {
+    const text = fs.readFileSync(laterNotePath(root), 'utf8');
+    return spokenLaterNote(String(text).split(/\r?\n/)[0]);
+  } catch {
+    return '';
+  }
+}
+
+function writeLaterNote(root, sentence) {
+  const remembered = spokenLaterNote(sentence);
+  if (!remembered) return '';
+  fs.writeFileSync(laterNotePath(root), `${remembered}\n`, 'utf8');
+  return remembered;
+}
+
+function resolveLaterNote({ root, later } = {}) {
+  if (later !== undefined) return spokenLaterNote(later);
+  return root ? readLaterNote(root) : '';
+}
+
+function laterNextCommand(files, extra = {}) {
+  const remembered = resolveLaterNote(extra);
+  if (!remembered) return '';
+  if (spokenVisibleNames(files).length) return 'atris';
+  return 'atris do';
+}
+
+function freshWinLine({ folder = 'this folder', files, root, commit, dirty, branch, later } = {}) {
+  const remembered = resolveLaterNote({ root, later });
+  if (remembered) return `${remembered} is still open.`;
+  const visible = spokenVisibleNames(files);
+  const open = resolveFreshOpenWork({ root, files: visible, commit, dirty });
+  if (open) return open;
+  const named = resolveFreshBranch({ root, files: visible, commit, branch });
+  if (named) return `${named} is already here.`;
+  const subject = resolveFreshCommit({ root, files: visible, commit });
+  if (subject) return `${subject} is already here.`;
+  if (visible.length === 1) return `${visible[0]} is already here.`;
+  if (visible.length === 2) return `${visible[0]} and ${visible[1]} are already here.`;
+  if (visible.length > 2) return 'this folder already has work.';
+  return `${folder || 'this folder'} is empty.`;
+}
+
+function freshNextCommand(files, folder = 'this folder', extra = {}) {
+  const laterNext = laterNextCommand(files, extra);
+  if (laterNext) return laterNext;
+  if (spokenVisibleNames(files).length) return 'atris do';
+  return firstTalkCommand(folder);
+}
+
+function renderLaterRemember({ person = '', sentence = '', files, root, later } = {}) {
+  const remembered = spokenLaterNote(sentence || later);
+  return [
+    `${greet(person)}I'll remember ${remembered}.`,
+    '',
+    `next: ${freshNextCommand(files, 'this folder', { root, later: remembered })}`,
+  ].join('\n');
+}
+
+function renderFresh({ person = '', folder = 'this folder', files, root, commit, dirty, branch, later } = {}) {
   const room = folder || 'this folder';
+  const extra = { root, later };
   return [
-    `${greet(person)}${room} is a clean start.`,
+    `${greet(person)}${freshWinLine({ folder: room, files, root, commit, dirty, branch, later })}`,
     '',
-    `next: ${INIT_COMMAND}`,
+    `next: ${freshNextCommand(files, room, extra)}`,
   ].join('\n');
 }
 
-function freshMinuteJson() {
+function spokenStarterTitle(title, folder = 'this folder') {
+  const text = String(title || '').replace(/\s+/g, ' ').trim();
+  if (!text) return folder || 'this folder';
+  return text.replace(/[.,;:!?]+$/g, '');
+}
+
+function visibleWorkTitle(files, folder = 'this folder') {
+  const visible = spokenVisibleNames(files);
+  if (visible.length === 1) return visible[0];
+  if (visible.length === 2) return `${visible[0]} and ${visible[1]}`;
+  return folder || 'this folder';
+}
+
+function firstTalkNext({ starter = null, person = '', folder = 'this folder' } = {}) {
+  const room = folder || 'this folder';
+  if (starter && starter.display_id) {
+    return taskCommand({
+      display_id: starter.display_id,
+      status: starter.status || 'claimed',
+    }, person);
+  }
+  const title = spokenStarterTitle(starter && starter.title, room);
+  return `atris task new "${title}"`;
+}
+
+function firstTalkJson({ starter = null, person = '', folder = 'this folder' } = {}) {
+  return {
+    schema: 'atris.one_lap.v1',
+    ok: true,
+    status: 'started',
+    next_action: firstTalkNext({ starter, person, folder }),
+    task: starter && starter.display_id
+      ? { display_id: starter.display_id, title: starter.title }
+      : null,
+  };
+}
+
+function renderFirstTalk({ person = '', folder = 'this folder', starter = null } = {}) {
+  const room = folder || 'this folder';
+  const title = spokenStarterTitle(starter && starter.title, room);
+  return [
+    `${greet(person)}${title} is ready.`,
+    '',
+    `next: ${firstTalkNext({ starter, person, folder: room })}`,
+  ].join('\n');
+}
+
+function freshMinuteJson(folder = 'this folder', files, extra = {}) {
+  const root = extra && extra.root;
+  const commit = extra && extra.commit;
+  const dirty = extra && extra.dirty;
+  const branch = extra && extra.branch;
+  const later = extra && extra.later;
+  const fields = { folder, files, root, commit, dirty, branch, later };
   return {
     schema: 'atris.one_lap.v1',
     ok: false,
     status: 'stuck',
-    reason: 'this workspace is not initialized',
-    next_action: `${INIT_COMMAND} --yes`,
+    reason: freshWinLine(fields).replace(/\.$/, ''),
+    next_action: freshNextCommand(files, folder, { root, later }),
   };
 }
 
@@ -272,24 +657,28 @@ function renderWorkspace({
   recap = null,
   completedTitle = '',
   nextCommand = FIRST_USE_COMMAND,
+  liveWork = false,
+  movingTitle = '',
 } = {}) {
   const who = greet(person);
   const title = task && softTitle(task.title);
   let win = `${who}${folder || 'this folder'} is set up.`;
   if (task && task.status === 'done' && title) {
     win = `${who}you already shipped ${title}.`;
-  } else if (task && task.status === 'review' && title) {
-    win = isCertifiedReview(task)
-      ? `${who}${title} is waiting for your ok.`
-      : `${who}${title} is ready to look at.`;
+  } else if (task && task.status === 'review') {
+    win = `${who}something finished. waiting on you.`;
   } else if (task && task.status === 'claimed' && title) {
     win = `${who}${title} is already yours.`;
   } else if (task && task.status === 'open' && title) {
     win = `${who}${title} is ready to claim.`;
-  } else if (completedTitle) {
+  } else if (movingTitle && liveWork) {
+    win = `${who}${softTitle(movingTitle)} is waiting.`;
+  } else if (completedTitle && !liveWork) {
     win = `${who}you already shipped ${softTitle(completedTitle)}.`;
-  } else if (recap && recap.title) {
+  } else if (recap && recap.title && !liveWork) {
     win = `${who}you already have a recap in ${folder || 'this folder'}: ${recap.title}.`;
+  } else if (liveWork) {
+    win = `${who}${folder || 'this folder'} has work in motion.`;
   }
   const lines = [win];
   if (recap && recap.title && task) lines.push(`last recap: ${recap.title}.`);
@@ -305,28 +694,66 @@ function buildFirstMinute({
   folder,
   context = {},
   missions = [],
+  files,
+  commit,
+  dirty,
+  branch,
+  later,
 } = {}) {
   const who = person != null ? person : personName();
   const room = folder != null ? folder : folderName(root);
   if (fresh) {
+    const visible = files != null ? spokenVisibleNames(files) : listUserVisibleWork(root);
+    const remembered = later !== undefined ? spokenLaterNote(later) : readLaterNote(root);
     return {
       kind: 'fresh',
-      text: renderFresh({ person: who, folder: room }),
-      nextCommand: INIT_COMMAND,
+      text: renderFresh({
+        person: who,
+        folder: room,
+        files: visible,
+        root,
+        commit,
+        dirty,
+        branch,
+        later: remembered,
+      }),
+      nextCommand: freshNextCommand(visible, room, { root, later: remembered }),
+      files: visible,
+      later: remembered,
     };
   }
   const tasks = loadLocalTasks(root);
+  const todoBacklog = titlesFromTodoSection(root, 'Backlog');
+  const todoWip = titlesFromTodoSection(root, 'In Progress');
+  const backlogCount = todoBacklog
+    ? todoBacklog.length
+    : (Array.isArray(context.backlogTasks) ? context.backlogTasks.length : 0);
+  const inboxCount = typeof context.inboxCount === 'number' ? context.inboxCount : 0;
+  const wipCount = todoWip
+    ? todoWip.length
+    : (Array.isArray(context.inProgressTasks) ? context.inProgressTasks.length : 0);
   const picked = pickNext({
     tasks,
     missions,
     person: who,
     completedTitles: Array.isArray(context.completedTasks) ? context.completedTasks : [],
-    backlogCount: Array.isArray(context.backlogTasks) ? context.backlogTasks.length : 0,
-    inboxCount: typeof context.inboxCount === 'number' ? context.inboxCount : 0,
-    wipCount: Array.isArray(context.inProgressTasks) ? context.inProgressTasks.length : 0,
+    backlogCount,
+    inboxCount,
+    wipCount,
   });
   const recap = loadLatestRecap(root);
   const completedTitle = Array.isArray(context.completedTasks) ? context.completedTasks[0] : '';
+  const movingTitle = (todoWip && todoWip[0])
+    || (todoBacklog && todoBacklog[0])
+    || (!todoBacklog && !todoWip && ((Array.isArray(context.inProgressTasks) && context.inProgressTasks[0])
+      || (Array.isArray(context.backlogTasks) && context.backlogTasks[0])))
+    || '';
+  const liveWork = hasLiveWork({
+    task: picked.task || null,
+    backlogCount,
+    wipCount,
+    inboxCount,
+  });
   return {
     kind: 'workspace',
     text: renderWorkspace({
@@ -336,6 +763,8 @@ function buildFirstMinute({
       recap,
       completedTitle,
       nextCommand: picked.command,
+      liveWork,
+      movingTitle,
     }),
     nextCommand: picked.command,
     task: picked.task || null,
@@ -350,6 +779,26 @@ function shouldAutoInitFresh(args = process.argv.slice(2), _env = process.env) {
   return list.includes('--yes') || list.includes('-y');
 }
 
+// Looking at the next task is not first-talk. A quoted `task next`
+// must not init a room in an empty folder.
+function isTaskNextLook(value) {
+  return /^task\s+next\b/i.test(String(value || '').trim());
+}
+
+const LEFTOVER_LOOK_VERBS = new Set(['brainstorm', 'wish', 'log', 'plan', 'do', 'later', 'mission', 'next']);
+
+// Leftover words after a known verb are not first-talk. A quoted
+// `brainstorm hi` / `wish hi` / `later hi` / `mission hi` / `next hi`
+// must not init a room or write a later note in an empty folder.
+function isLeftoverVerbLook(value) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return false;
+  if (isTaskNextLook(text)) return true;
+  const match = text.match(/^([A-Za-z][\w-]*)\s+\S/);
+  if (!match) return false;
+  return LEFTOVER_LOOK_VERBS.has(match[1].toLowerCase());
+}
+
 function spokenLineCount(text) {
   return String(text || '')
     .split(/\n+/)
@@ -366,33 +815,129 @@ function speakFirstMinute({
   fresh,
   asJson = false,
   log = console.log,
+  files,
 } = {}) {
   const isFresh = fresh != null ? Boolean(fresh) : isFreshWorkspace(root);
+  const visible = files != null ? spokenVisibleNames(files) : listUserVisibleWork(root);
   if (asJson && isFresh) {
-    log(JSON.stringify(freshMinuteJson(), null, 2));
+    log(JSON.stringify(freshMinuteJson(folderName(root), visible, { root }), null, 2));
     return 2;
   }
-  const screen = buildFirstMinute({ root, fresh: isFresh });
+  const screen = buildFirstMinute({
+    root,
+    fresh: isFresh,
+    files: isFresh ? visible : undefined,
+  });
   log('');
   log(screen.text);
   return 0;
 }
 
+function speakNothingRunning({
+  root = process.cwd(),
+  asJson = false,
+  log = console.log,
+  files,
+} = {}) {
+  // Empty folder: nothing is running, same talk next as bare atris.
+  // A file or later note already here: name it, next is do. Do not mint.
+  const visible = files != null ? spokenVisibleNames(files) : listUserVisibleWork(root);
+  if (visible.length || resolveLaterNote({ root })) {
+    return speakFirstMinute({ root, fresh: true, asJson, log, files: visible });
+  }
+  const next = firstTalkCommand();
+  if (asJson) {
+    log(JSON.stringify({
+      schema: 'atris.one_lap.v1',
+      ok: false,
+      status: 'stuck',
+      reason: 'nothing is running',
+      next_action: next,
+    }, null, 2));
+    return 2;
+  }
+  log('');
+  log(`${greet(personName())}nothing is running.\n\nnext: ${next}`);
+  return 0;
+}
+
+function spokenWinReason(text) {
+  const line = String(text || '').split('\n').map((s) => s.trim()).find(Boolean) || '';
+  return line.replace(/^hey [^,]+, /i, '').replace(/\.$/, '');
+}
+
+function isKeepWorkingMinute(minute) {
+  const next = String((minute && minute.nextCommand) || '');
+  if (next === 'atris do') return true;
+  return isClaimedKeepWorkingCommand(next);
+}
+
+function isClaimMinute(minute) {
+  return Boolean(minute && /^atris task claim\b/.test(minute.nextCommand || ''));
+}
+
+function speakKeepWorkingMinute({
+  root = process.cwd(),
+  asJson = false,
+  log = console.log,
+} = {}) {
+  // Just-minted file folder, nothing running: same two lines as
+  // first-minute / the next do. Not the factory board.
+  const minute = buildFirstMinute({ root });
+  if (asJson) {
+    const task = minute.task && minute.task.display_id
+      ? { display_id: minute.task.display_id, title: minute.task.title }
+      : null;
+    log(JSON.stringify({
+      schema: 'atris.one_lap.v1',
+      ok: true,
+      status: 'started',
+      reason: spokenWinReason(minute.text),
+      next_action: minute.nextCommand,
+      task,
+    }, null, 2));
+    return 0;
+  }
+  log('');
+  log(minute.text);
+  return 0;
+}
+
 module.exports = {
   buildFirstMinute,
   deskNextCommand,
+  firstTalkCommand,
+  firstTalkJson,
+  firstTalkNext,
   folderName,
   freshMinuteJson,
+  freshNextCommand,
+  laterNextCommand,
+  laterNotePath,
   isBareAtrisFlag,
   isCertifiedReview,
+  isFirstTalkLine,
   isFreshWorkspace,
+  isLeftoverVerbLook,
+  isTaskNextLook,
+  listUserVisibleWork,
   personName,
   pickNext,
+  renderFirstTalk,
+  renderLaterRemember,
+  spokenLaterNote,
+  visibleWorkTitle,
   renderFresh,
   renderWorkspace,
   shouldAutoInitFresh,
   speakFirstMinute,
+  speakKeepWorkingMinute,
+  speakNothingRunning,
   spokenLineCount,
+  spokenWinReason,
+  isKeepWorkingMinute,
+  isClaimMinute,
   taskCommand,
   taskNextCommand,
+  writeLaterNote,
 };