atris 3.74.0 → 3.74.1

package/lib/agent-today.js

@@ -0,0 +1,412 @@
+// What your ai coding agents did in this folder today. Reads Claude Code
+// and Codex session logs plus git, all local. Sends nothing anywhere and
+// needs no atris/ folder.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const CLAUDE_EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+const PATCH_FILE_RE = /\*\*\* (?:Add|Update|Delete) File: ([^\n\\"]+)/g;
+
+function startOfToday(now = new Date()) {
+  const d = new Date(now);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+function readJsonl(file) {
+  let text = '';
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+      // half-written last line while the agent is still running
+    }
+  }
+  return rows;
+}
+
+// Only the first line, so a busy day of logs from other folders costs a
+// small read each instead of the whole file.
+function readFirstJsonLine(file, maxBytes = 1024 * 1024) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const chunks = [];
+    const buf = Buffer.alloc(64 * 1024);
+    let total = 0;
+    while (total < maxBytes) {
+      const n = fs.readSync(fd, buf, 0, buf.length, total);
+      if (n <= 0) break;
+      const nl = buf.subarray(0, n).indexOf(10);
+      chunks.push(Buffer.from(buf.subarray(0, nl === -1 ? n : nl)));
+      total += n;
+      if (nl !== -1) break;
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+function touchedSince(file, since) {
+  try {
+    return fs.statSync(file).mtimeMs >= since.getTime();
+  } catch {
+    return false;
+  }
+}
+
+function isToday(row, since) {
+  const t = Date.parse(row && row.timestamp);
+  return Number.isFinite(t) && t >= since.getTime();
+}
+
+function realPrompt(text) {
+  const s = String(text || '').trim();
+  if (!s) return false;
+  // harness wrappers and the project notes codex injects, not something
+  // the person typed
+  return !s.startsWith('<') && !s.startsWith('Caveat:') && !s.startsWith('# AGENTS.md instructions')
+    && !s.startsWith('[Request interrupted');
+}
+
+// Claude Code saves a typed ask as plain text, or as a list when it has a
+// picture. A list carrying tool results is the tool talking back, not an ask.
+function claudeAskText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content) || content.some((c) => c && c.type === 'tool_result')) return '';
+  return content.filter((c) => c && c.type === 'text').map((c) => c.text || '').join('\n');
+}
+
+// Claude Code marks hook feedback, image notes, and the summary of a
+// condensed chat on the row itself. None of those are asks.
+function claudeHarnessRow(row) {
+  return Boolean(row.isMeta || row.isCompactSummary || row.isVisibleInTranscriptOnly);
+}
+
+// A program started this chat (claude -p, the agent sdk), not a person
+// typing in the app.
+function claudeStartedByProgram(row) {
+  return row.promptSource === 'sdk' || /^sdk/.test(String(row.entrypoint || ''));
+}
+
+// Codex helpers carry a parent link and belong to another session.
+// codex exec is a program run; the desktop app and terminal app are chats.
+function codexOrigin(meta) {
+  const src = meta && meta.source;
+  if (src && typeof src === 'object' && src.subagent) return 'helper';
+  if ((meta && meta.originator) === 'codex_exec' || src === 'exec') return 'auto';
+  return 'you';
+}
+
+// Claude Code keys each folder by its path with every non-alphanumeric
+// character turned into a dash.
+function claudeProjectDir(home, cwd, env = {}) {
+  return path.join(claudeRoot(home, env), 'projects', cwd.replace(/[^a-zA-Z0-9]/g, '-'));
+}
+
+// Past 200 characters Claude Code keeps the first 200 and adds a short
+// code, so a deep folder is found by that prefix. Two deep folders can
+// share it, so those logs are confirmed by the folder they record.
+const CLAUDE_KEY_MAX = 200;
+
+function claudeProjectDirs(home, cwd, env = {}) {
+  const exact = claudeProjectDir(home, cwd, env);
+  const key = path.basename(exact);
+  if (key.length <= CLAUDE_KEY_MAX) return { dirs: [exact], shortened: false };
+  const root = path.dirname(exact);
+  const prefix = `${key.slice(0, CLAUDE_KEY_MAX)}-`;
+  let names = [];
+  try {
+    names = fs.readdirSync(root).filter((n) => n.startsWith(prefix));
+  } catch {}
+  return { dirs: [exact, ...names.map((n) => path.join(root, n))], shortened: true };
+}
+
+function sameFolder(recorded, aliases) {
+  return aliases.includes(recorded) || realOr(recorded) === aliases[0];
+}
+
+// Both tools let people move their log folder; look where they look.
+function claudeRoot(home, env = {}) {
+  return env.CLAUDE_CONFIG_DIR || path.join(home, '.claude');
+}
+
+function codexRoot(home, env = {}) {
+  return env.CODEX_HOME || path.join(home, '.codex');
+}
+
+function readClaude({ home, env, aliases, since }) {
+  const files = new Map();
+  for (const alias of aliases) {
+    const { dirs, shortened } = claudeProjectDirs(home, alias, env);
+    for (const dir of dirs) {
+      try {
+        for (const n of fs.readdirSync(dir)) {
+          const file = path.join(dir, n);
+          if (n.endsWith('.jsonl') && !files.has(file)) files.set(file, shortened);
+        }
+      } catch {}
+    }
+  }
+  const sessions = [];
+  for (const [file, shortened] of files) {
+    if (!touchedSince(file, since)) continue;
+    const rows = readJsonl(file);
+    // Folders like my-app and my_app share one log folder, so trust the
+    // folder each log records. A deep folder's log must record one.
+    const recorded = rows.find((r) => r && r.cwd);
+    if (recorded ? !sameFolder(recorded.cwd, aliases) : shortened) continue;
+    const s = { tool: 'claude', origin: null, prompts: 0, files: new Set(), lastPrompt: '' };
+    for (const row of rows) {
+      if (!isToday(row, since) || row.isSidechain) continue;
+      const content = row.message && row.message.content;
+      const ask = row.type === 'user' ? claudeAskText(content) : '';
+      if (ask && !claudeHarnessRow(row) && realPrompt(ask)) {
+        if (!s.origin) s.origin = claudeStartedByProgram(row) ? 'auto' : 'you';
+        s.prompts += 1;
+        s.lastPrompt = ask.trim();
+      }
+      if (row.type === 'assistant' && Array.isArray(content)) {
+        for (const c of content) {
+          if (c && c.type === 'tool_use' && CLAUDE_EDIT_TOOLS.has(c.name)) {
+            const p = c.input && (c.input.file_path || c.input.notebook_path);
+            if (p) s.files.add(p);
+          }
+        }
+      }
+    }
+    if (!s.origin) s.origin = 'you';
+    if (s.prompts || s.files.size) sessions.push(s);
+  }
+  return sessions;
+}
+
+// Codex files a session under the day it started, and a session picked
+// back up later keeps writing there. So every day folder is listed, and
+// only logs changed since midnight are opened.
+function codexDayDirs(home, env) {
+  const root = path.join(codexRoot(home, env), 'sessions');
+  const dirs = [];
+  const list = (p) => {
+    try {
+      return fs.readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path.join(p, e.name));
+    } catch {
+      return [];
+    }
+  };
+  for (const y of list(root)) for (const m of list(y)) dirs.push(...list(m));
+  return dirs;
+}
+
+function insideFolder(child, folder) {
+  if (!child) return false;
+  const rel = path.relative(folder, child);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+function readCodex({ home, env, aliases, since }) {
+  // Codex records the folder as typed, shortcut and all, so a session
+  // started through a shortcut is resolved before it is compared.
+  const here = (child) => aliases.some((a) => insideFolder(child, a))
+    || insideFolder(realOr(child), aliases[0]);
+  const sessions = [];
+  for (const dir of codexDayDirs(home, env)) {
+    let names = [];
+    try {
+      names = fs.readdirSync(dir).filter((n) => n.endsWith('.jsonl'));
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const file = path.join(dir, name);
+      if (!touchedSince(file, since)) continue;
+      const first = readFirstJsonLine(file);
+      if (first && first.type === 'session_meta' && !here(first.payload && first.payload.cwd)) continue;
+      const rows = readJsonl(file);
+      const meta = rows.find((r) => r.type === 'session_meta');
+      if (!meta || !here(meta.payload && meta.payload.cwd)) continue;
+      const s = { tool: 'codex', origin: codexOrigin(meta.payload), prompts: 0, files: new Set(), lastPrompt: '' };
+      const started = meta.payload.cwd;
+      const resolved = realOr(started) || started;
+      // edits recorded under the shortcut are moved onto the real folder
+      const onReal = (p) => (path.isAbsolute(p) && insideFolder(p, started) ? path.join(resolved, path.relative(started, p)) : p);
+      for (const row of rows) {
+        if (!isToday(row, since) || row.type !== 'response_item') continue;
+        const p = row.payload || {};
+        if (p.type === 'message' && p.role === 'user') {
+          const text = (p.content || []).map((c) => (c && c.text) || '').join('\n');
+          if (realPrompt(text)) {
+            s.prompts += 1;
+            s.lastPrompt = text.trim();
+          }
+        }
+        if (p.type === 'custom_tool_call' || p.type === 'function_call') {
+          const raw = String(p.input || p.arguments || '');
+          for (const m of raw.matchAll(PATCH_FILE_RE)) s.files.add(onReal(m[1].trim()));
+        }
+      }
+      if (s.prompts || s.files.size) sessions.push(s);
+    }
+  }
+  return sessions;
+}
+
+// Read only: git status would otherwise refresh its own index file.
+function git(cwd, args) {
+  const r = spawnSync('git', ['--no-optional-locks', ...args], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  return r.status === 0 ? r.stdout : null;
+}
+
+function readGit({ cwd, since }) {
+  if (git(cwd, ['rev-parse', '--is-inside-work-tree']) === null) return null;
+  // From a subfolder of a bigger repo, count only that subfolder, so it is
+  // not credited with its neighbors' work. At the top, no limit, which
+  // would also hide merges. Every new file counts, not just its folder.
+  const sub = (git(cwd, ['rev-parse', '--show-prefix']) || '').trim();
+  const log = git(cwd, ['log', `--since=${since.toISOString()}`, '--pretty=%s', ...(sub ? ['--', '.'] : [])]) || '';
+  const commits = log.split('\n').map((s) => s.trim()).filter(Boolean);
+  const status = git(cwd, ['status', '--porcelain', '--untracked-files=all', '--', '.']) || '';
+  const unsaved = status.split('\n').filter((l) => l.trim()).length;
+  return { commits, unsaved };
+}
+
+function relativeTo(cwd, file) {
+  const abs = path.isAbsolute(file) ? file : path.join(cwd, file);
+  const rel = path.relative(cwd, abs);
+  return rel.startsWith('..') ? null : rel;
+}
+
+function topAreas(files, limit = 2) {
+  const counts = new Map();
+  for (const f of files) {
+    const parts = f.split(path.sep);
+    const area = parts.length > 1 ? parts[0] : 'the top folder';
+    counts.set(area, (counts.get(area) || 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([a]) => a);
+}
+
+function realOr(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return null;
+  }
+}
+
+// Every name this folder goes by. The tools record the path you started
+// in, which can run through a symlink, and the shell's PWD keeps that
+// path even after node resolves it.
+function folderAliases(cwd, env = {}) {
+  const real = realOr(cwd) || cwd;
+  const aliases = [real];
+  for (const p of [cwd, env.PWD]) {
+    if (p && path.isAbsolute(p) && !aliases.includes(p) && realOr(p) === real) aliases.push(p);
+  }
+  return aliases;
+}
+
+function buildAgentToday({ cwd = process.cwd(), home = os.homedir(), env = process.env, now = new Date() } = {}) {
+  const aliases = folderAliases(cwd, env);
+  const folder = aliases[0];
+  const since = startOfToday(now);
+  const sessions = [
+    ...readClaude({ home, env, aliases, since }),
+    ...readCodex({ home, env, aliases, since }),
+  ];
+  const files = new Set();
+  for (const s of sessions) {
+    for (const f of s.files) {
+      const rel = aliases.map((a) => relativeTo(a, f)).find(Boolean);
+      if (rel) files.add(rel);
+    }
+  }
+  const gitInfo = readGit({ cwd: folder, since });
+  const yours = sessions.filter((s) => s.origin === 'you');
+  return {
+    folder: path.basename(folder),
+    since: since.toISOString(),
+    sessions: {
+      claude: yours.filter((s) => s.tool === 'claude').length,
+      codex: yours.filter((s) => s.tool === 'codex').length,
+    },
+    prompts: yours.reduce((n, s) => n + s.prompts, 0),
+    autoRuns: sessions.filter((s) => s.origin === 'auto').length,
+    files: [...files].sort(),
+    areas: topAreas([...files]),
+    commits: gitInfo ? gitInfo.commits : [],
+    unsaved: gitInfo ? gitInfo.unsaved : 0,
+    isGit: Boolean(gitInfo),
+  };
+}
+
+function hasActivity(t) {
+  return Boolean(t && (ranAgent(t) || t.commits.length > 0));
+}
+
+function ranAgent(t) {
+  return t.sessions.claude + t.sessions.codex + (t.autoRuns || 0) > 0;
+}
+
+function plural(n, one, many = `${one}s`) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+
+function quote(text, width = 60) {
+  const s = String(text).replace(/\s+/g, ' ').trim();
+  return s.length > width ? `${s.slice(0, width - 3).trimEnd()}...` : s;
+}
+
+// Five lines at most, plain words, one idea each.
+function renderAgentToday(t) {
+  const lines = [`today in ${t.folder}`];
+  const total = t.sessions.claude + t.sessions.codex;
+  if (!hasActivity(t)) {
+    lines.push('no ai sessions or saved changes here yet today.');
+    lines.push('run this again after your agent does some work.');
+    return lines.join('\n');
+  }
+  if (total) {
+    const who = [
+      t.sessions.claude ? `${plural(t.sessions.claude, 'session')} in claude code` : '',
+      t.sessions.codex ? `${plural(t.sessions.codex, 'session')} in codex` : '',
+    ].filter(Boolean).join(' and ');
+    lines.push(`you asked your ai agent for ${plural(t.prompts, 'thing')}, across ${who}.`);
+  }
+  if (t.autoRuns) {
+    lines.push(`your agents ${total ? 'also ' : ''}ran ${plural(t.autoRuns, 'job')} on their own.`);
+  }
+  if (t.files.length) {
+    const where = t.files.length === 1 ? ` in ${t.areas[0]}` : `, mostly in ${t.areas.join(' and ')}`;
+    lines.push(`it changed ${plural(t.files.length, 'file')}${where}.`);
+  } else if (ranAgent(t)) {
+    lines.push('it read and ran things but changed no files.');
+  }
+  const saved = t.commits.length
+    ? `${plural(t.commits.length, 'change')} saved to git. latest: "${quote(t.commits[0])}"`
+    : '';
+  const unsaved = t.unsaved ? `${plural(t.unsaved, 'file')} changed but not saved to git yet.` : '';
+  if (saved && unsaved && lines.length + 2 > 5) {
+    // keep five lines: one git line says both
+    lines.push(`${plural(t.commits.length, 'change')} saved to git, ${plural(t.unsaved, 'file')} not saved yet.`);
+  } else {
+    if (saved) lines.push(saved);
+    if (unsaved) lines.push(unsaved);
+    else if (t.isGit && t.files.length) lines.push('everything it changed is saved to git.');
+  }
+  return lines.slice(0, 5).join('\n');
+}
+
+module.exports = { buildAgentToday, renderAgentToday, hasActivity, ranAgent, claudeProjectDir, startOfToday, readFirstJsonLine, folderAliases };

package/lib/autoland.js

@@ -492,14 +492,6 @@ function unexplainedSummaryRows(items, label) {
   return [`${plur(count, label)} stayed hidden because ${count === 1 ? 'its meaning was' : 'their meanings were'} unclear`];
 }
 
-function missionDigestLine(mission, max = 160) {
-  const visibleGoal = mission?.visible_goal?.desired_objective
-    || mission?.goal?.visible_goal?.desired_objective
-    || (typeof mission?.visible_goal === 'string' ? mission.visible_goal : '');
-  const objective = visibleGoal || mission?.objective || '';
-  return finishThought(clarify(objective, max), max);
-}
-
 // Some older surfaces still need a readable fallback for rough text, but the
 // digest paths above now hide agent-speak until a result sentence exists.
 function dejargon(line, options = {}) {

package/lib/bench/runner.js

@@ -30,10 +30,6 @@ function packDir(repoRoot = repoRootFromHere(), pack = DEFAULT_PACK) {
   return path.join(benchmarksRoot(repoRoot), pack || DEFAULT_PACK);
 }
 
-function defaultTasksDir(repoRoot = repoRootFromHere()) {
-  return packDir(repoRoot, DEFAULT_PACK);
-}
-
 function validateTaskSpec(spec, filePath) {
   if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
     throw new BenchInfraError(`${filePath}: task spec must export an object`);

package/lib/chat-log-scan.js

@@ -341,34 +341,6 @@ function writeLatestScan(root, report) {
   return latestPath;
 }
 
-function readLatestScan(root) {
-  const latestPath = path.join(root, '.atris', 'state', 'chat_scan.latest.json');
-  try {
-    if (!fs.existsSync(latestPath)) return null;
-    return JSON.parse(fs.readFileSync(latestPath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function ensureChatScan(root, options = {}) {
-  const maxAgeMs = Number(options.maxAgeMs ?? 3600000);
-  const existing = readLatestScan(root);
-  if (existing && existing.scanned_at && !options.force) {
-    const age = Date.now() - new Date(existing.scanned_at).getTime();
-    if (Number.isFinite(age) && age >= 0 && age <= maxAgeMs) {
-      return existing;
-    }
-  }
-  const report = scanChatLogs({ cwd: root, hours: options.hours, limit: options.limit });
-  if (options.write !== false) writeLatestScan(root, report);
-  return report;
-}
-
-function topChatFindings(report, limit = 3) {
-  return (report && Array.isArray(report.findings) ? report.findings : []).slice(0, limit);
-}
-
 module.exports = {
   SCHEMA,
   scanChatLogs,

package/lib/cli-scope.js

@@ -16,8 +16,10 @@ function pathUnderRoot(candidate, root) {
   if (!candidate || !root) return false;
   const resolvedCandidate = path.resolve(String(candidate));
   const resolvedRoot = path.resolve(String(root));
-  return resolvedCandidate === resolvedRoot
-    || resolvedCandidate.startsWith(`${resolvedRoot}${path.sep}`);
+  if (resolvedCandidate === resolvedRoot) return true;
+  // A filesystem root already ends in a separator ('/' or 'C:\\').
+  const prefix = resolvedRoot.endsWith(path.sep) ? resolvedRoot : `${resolvedRoot}${path.sep}`;
+  return resolvedCandidate.startsWith(prefix);
 }
 
 module.exports = {

package/lib/engine-registry.js

@@ -1748,10 +1748,6 @@ function engineRegistryView(root = process.cwd()) {
   return readEngineRegistry(root).engines;
 }
 
-function registeredEngineIds(root = process.cwd()) {
-  return engineRegistryView(root).map((engine) => engine.id);
-}
-
 function resolveRegisteredEngine(name, root = process.cwd()) {
   const requested = String(name || '').trim();
   const id = canonicalEngineName(requested);

package/lib/file-ops.js

@@ -9,7 +9,12 @@ const escapeRegExp = require('./escape-regexp');
  */
 function getLogPath(dateStr) {
   const targetDir = path.join(process.cwd(), 'atris');
-  const date = dateStr ? new Date(dateStr) : new Date();
+  // A bare YYYY-MM-DD is that calendar day here. new Date('2026-10-22') is
+  // UTC midnight, which is the evening before anywhere west of Greenwich.
+  const dayOnly = typeof dateStr === 'string' && dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  const date = dayOnly
+    ? new Date(Number(dayOnly[1]), Number(dayOnly[2]) - 1, Number(dayOnly[3]))
+    : (dateStr ? new Date(dateStr) : new Date());
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, '0');
   const day = String(date.getDate()).padStart(2, '0');

package/lib/first-minute.js

@@ -178,6 +178,8 @@ function loadLocalTasks(root = process.cwd()) {
   let dbRows = [];
   try {
     const taskDb = require('./task-db');
+    // Reading never creates the db, so a first look writes nothing.
+    if (!fs.existsSync(taskDb.getDbPath())) throw new Error('no task db yet');
     const db = taskDb.open();
     const workspaceRoot = taskDb.workspaceRoot(root);
     const rows = taskDb.listTasks(db, { workspaceRoot, limit: 200 });

package/lib/gm-bet.js

@@ -152,6 +152,8 @@ function readScoreboard(file, workspaceRoot) {
     if (!row || row.workspace !== workspaceRoot) continue;
     if (row.kind === 'pick' && row.name) board = { name: row.name, up: row.up !== false, source: row.source === 'installs' ? 'installs' : 'reported', at: row.at, reports: [] };
     else if (row.kind === 'report' && board && Number.isFinite(row.value)) board.reports.push({ value: row.value, at: row.at });
+    // the owner stopped tracking it: no number until one is picked again
+    else if (row.kind === 'clear') board = null;
   }
   return board;
 }
@@ -348,6 +350,8 @@ function buildQuestionRewrite(previous, reasons) {
 
 const SAY_READ_MS = 15000;
 const SAY_KINDS = new Set(['question', 'answer', 'instruction', 'unclear']);
+// on the weekly number card, what an instruction wants done with the number
+const NUMBER_INTENTS = new Set(['stop', 'change', 'later', 'other']);
 const SAY_FALLBACK = 'say that another way, or tap a button.';
 // the last turns of a card's conversation the reader sees
 const THREAD_TURNS = 6;
@@ -380,6 +384,7 @@ async function readSaid({ text, card, thread = [], hint = null, workspaceRoot, b
     '- unclear: you cannot tell. reply: one short question back.',
     '- a message that ends with "?" or asks why, what, or how is a question back, never an answer.',
     '- you may add "suggestions": 0 to 3 short replies he could tap next, each under 40 characters.',
+    card.kind === 'number' ? '- on this number card an instruction also has "intent": "stop" when he wants to stop tracking this number, "change" when he wants a different number, "later" when he wants to be asked another time, else "other". for "other", reply says what this card can do.' : '',
     `- plain lowercase-friendly words, no em dashes, and never these words: ${OWNER_BANNED_WORDS.join(', ')}.`,
     '',
     `## the card on screen (${card.kind})`,
@@ -404,7 +409,8 @@ async function readSaid({ text, card, thread = [], hint = null, workspaceRoot, b
   const v = parsed.bet;
   if (!v || !SAY_KINDS.has(v.kind) || typeof v.reply !== 'string') return { ok: false, reason: 'the read was not the shape asked for' };
   const suggestions = Array.isArray(v.suggestions) ? v.suggestions.filter(x => typeof x === 'string' && x.trim()).map(x => x.trim()) : [];
-  return { ok: true, kind: v.kind, reply: clip(v.reply, 280), ...(suggestions.length ? { suggestions } : {}) };
+  const intent = card.kind === 'number' && NUMBER_INTENTS.has(v.intent) ? v.intent : null;
+  return { ok: true, kind: v.kind, reply: clip(v.reply, 280), ...(intent ? { intent } : {}), ...(suggestions.length ? { suggestions } : {}) };
 }
 
 // Two or three numbers that would tell the owner this project is going well,
@@ -2709,10 +2715,11 @@ function createBetDesk(deps) {
         question: { key: 'scoreboard', ask: SCOREBOARD_ASK, line: null, choices: [...list.map((c, i) => ({ id: `s${i + 1}`, label: c.name })), { id: 'other', label: 'something else', other: true }], numbers: list },
       };
     }
-    if (board.source !== 'reported' || state.passedQuestions.has('report')) return null;
+    const today = dayKey(now());
+    // passed over today (not now, or a tap past it): asked again tomorrow
+    if (board.source !== 'reported' || state.passedQuestions.has(`report:${today}`)) return null;
     const last = board.reports[board.reports.length - 1] || null;
     const weekly = !last || now() - (Date.parse(last.at) || 0) >= WEEK_MS;
-    const today = dayKey(now());
     const waiting = readLedger(deps.ledgerFile, deps.workspaceRoot).some(r => r.status === 'doing' && r.bet && r.bet.target && r.bet.target.metric === 'scoreboard'
       && String(r.bet.check_date || '') < today && !board.reports.some(x => String(x.at).slice(0, 10) >= r.bet.check_date));
     if (!weekly && !waiting) return null;
@@ -2860,7 +2867,7 @@ function createBetDesk(deps) {
   // a re-tap on a job card moves on: a yes waits for a later session, a done is seen
   function passJob(item) {
     if (item.kind === 'wait') return;
-    if (item.kind === 'report') { state.passedQuestions.add('report'); return; }
+    if (item.kind === 'report') { state.passedQuestions.add(item.id); return; }
     if (item.kind === 'choice') {
       for (const i of item.items) record(i.id, { status: 'passed', note: 'not picked' });
       log({ card: 'bet', choice: 'pass', command: null, ran: 'in process', exit_code: 0, kind: 'choice' });
@@ -3279,7 +3286,7 @@ function createBetDesk(deps) {
     if (v.kind === 'question') return { kind: 'question', title: v.question.ask, detail: v.question.line, buttons: v.question.choices.map(c => c.label) };
     if (v.kind === 'bet') return { kind: 'idea', title: v.bet.title, detail: [v.bet.why_now, v.bet.expect].join(' '), buttons: ['do it', 'sharper idea', 'not now'] };
     if (v.kind === 'choice') return { kind: 'choice', title: 'which one next?', detail: v.choice.options.map(o => o.title).join(' / '), buttons: [] };
-    if (v.kind === 'report') return { kind: 'number', title: v.report.what, detail: v.report.why, buttons: [] };
+    if (v.kind === 'report') return { kind: 'number', title: v.report.what, detail: v.report.why, buttons: ['save', 'not now'] };
     return { kind: v.kind, title: v.job ? v.job.what : '', detail: v.job ? v.job.why : '', buttons: [] };
   }
 
@@ -3349,6 +3356,35 @@ function createBetDesk(deps) {
       pump();
       return { ok: true, ack: plainReply(read.reply) || 'got it. the next idea will fit that.' };
     }
+    // Words on the weekly number card are about that number, and the
+    // reader says what they want. A plain number is this week's value. Stop
+    // tracking this, or pick a different number, stops tracking it, and the
+    // next card asks which number, if any. Ask me tomorrow is not now. Any
+    // other answer or instruction gets a reply on the card and changes nothing.
+    if (kind === 'report') {
+      const stay = (reply) => {
+        addTurns(t, { who: 'owner', text: said }, { who: 'orb', text: reply });
+        return { ok: true, stay: true, kind: 'unclear', reply, thread: t.turns.slice() };
+      };
+      if (read.kind === 'answer') {
+        const saved = report({ value: said });
+        if (saved.ok) { endThread(); return saved; }
+        return stay('type this week\'s number in the box, or say stop tracking this.');
+      }
+      if (read.intent === 'later') {
+        passJob(cur);
+        state.status = 'cleared';
+        endThread();
+        return { ok: true, ack: 'got it. i will ask tomorrow.' };
+      }
+      if (read.intent !== 'stop' && read.intent !== 'change') return stay(plainReply(read.reply) || 'this card keeps one number a week. say stop tracking this, or ask me tomorrow.');
+      const name = cur.board.name;
+      appendLedger(scoreboardFile, { workspace: deps.workspaceRoot, kind: 'clear', name, at: iso() });
+      log({ card: 'bet', choice: 'scoreboard_clear', command: null, ran: 'in process', exit_code: 0 });
+      state.status = 'cleared';
+      endThread();
+      return { ok: true, ack: `got it. i stopped tracking ${name}.` };
+    }
     if (kind === 'yes' || kind === 'done') {
       const out = await steer({ member: cur.job.owner, text: said, confirm, note });
       if (out.ok) endThread();

package/lib/gm-phone-page.js

@@ -752,15 +752,18 @@ body.has-card .foot { position: static; margin-top: 28px; }
       b.addEventListener('click', function () {
         if (bet.busy) return;
         buzz();
-        if (c.other) { typeHere(b, c.label, 60, function (text, field) { answer(field, { choice: 'other', text: text }); }); return; }
+        // typed words are read first, so a question back is explained and nothing is saved
+        if (c.other) { typeHere(b, c.label, 60, function (text, field) { say(field, { text: text }); }); return; }
         answer(b, { choice: c.id });
       });
+      if (c.other) b.classList.add('other');
       act.appendChild(b);
     });
     // a quiet line under the answers, empty until an answer does not go through
     act.appendChild(el('div', 'links'));
     box.appendChild(act);
-    box.appendChild(sayBox());
+    // its own something else box is the one place to type
+    if (!q.choices.some(function (c) { return c.other; })) box.appendChild(sayBox());
   }
 
   // ---- answering in place: the eyes stay in one spot ----------------------------
@@ -948,7 +951,7 @@ body.has-card .foot { position: static; margin-top: 28px; }
       act.appendChild(sayChoice('keep it as a note instead', { text: said, note: true }));
     }
     box.appendChild(act);
-    box.appendChild(sayBox());
+    if (!own || !own.querySelector('.other')) box.appendChild(sayBox());
   }
 
   // the owner's own number, once a week: one box and one tap to save
@@ -978,7 +981,15 @@ body.has-card .foot { position: static; margin-top: 28px; }
     input.addEventListener('keydown', function (e) { if (e.key === 'Enter') { e.preventDefault(); go(); } });
     act.appendChild(input);
     act.appendChild(save);
+    // a quiet way out: moves on, saves nothing, and is not asked again today
+    var links = el('div', 'links');
+    var later = el('button', null, 'not now');
+    later.type = 'button';
+    later.addEventListener('click', function () { if (bet.busy) return; buzz(); think(false, 0); });
+    links.appendChild(later);
+    act.appendChild(links);
     box.appendChild(act);
+    box.appendChild(sayBox());
   }
 
   // A conversation in one box. While the words are read the reply spot shows