atris 3.80.1 → 3.82.2

package/commands/autoland.js

@@ -9,7 +9,8 @@ const { localDay } = require('../lib/local-day');
 const autoland = require('../lib/autoland');
 const { gateForHuman, plainLandingReason } = require('../lib/voice-gate');
 const { evaluateAutoAccept } = require('../lib/auto-accept-certified');
-const { sweepEngineAskReceipts } = require('../lib/engine-receipt-sweep');
+const { sweepEngineAskReceipts, sweepFleetReceipts } = require('../lib/engine-receipt-sweep');
+const { acquireFileLock } = require('../lib/file-lock');
 const { readSshAgents, findLeakedSshAgents, findAgentStartLines, agentStartLineText, stopLeakedSshAgents, closeLostRuns, readResourceHistory, errorReason, leakGrowthNote } = require('../lib/engine-resource');
 const { validateRecentAskReceipts } = require('../lib/engine-validate');
 const { operatorReady, hasAgentJargon, explainResult } = autoland;
@@ -731,15 +732,6 @@ function runDigest(root, args, { forceSend = false } = {}) {
   return 0;
 }
 
-function pidAlive(pid) {
-  try {
-    process.kill(Number(pid), 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 async function runTick(root, args) {
   const json = args.includes('--json');
   const policy = autoland.readPolicy(root);
@@ -756,24 +748,23 @@ async function runTick(root, args) {
   // double-alarms, and double-digests. A stale lock (dead pid or >55min)
   // never wedges the loop.
   const lockPath = path.join(root, '.atris', 'state', 'autoland.tick.lock');
+  let lock;
   try {
-    const prev = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
-    const fresh = Date.now() - Number(prev.at || 0) < 55 * 60 * 1000;
-    if (fresh && pidAlive(prev.pid)) {
-      receipt.skipped_reason = 'tick_already_running';
-      if (json) console.log(JSON.stringify(receipt));
-      else console.log('autoland tick: another tick is still running; skipped.');
-      return 0;
-    }
-  } catch {}
-  try {
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, at: Date.now() }));
-  } catch {}
+    lock = acquireFileLock(lockPath, { staleAfterMs: 55 * 60 * 1000 });
+  } catch {
+    lock = null;
+  }
+  if (lock && !lock.ok) {
+    receipt.skipped_reason = 'tick_already_running';
+    if (json) console.log(JSON.stringify(receipt));
+    else console.log('autoland tick: another tick is still running; skipped.');
+    return 0;
+  }
   try {
     return await runTickBody(root, { json, policy, receipt });
   } finally {
-    try { fs.unlinkSync(lockPath); } catch {}
+    // Only removes the lock while it is still this tick's.
+    if (lock) lock.release();
   }
 }
 
@@ -864,8 +855,10 @@ function digestTickStatus(receipt) {
 
 function engineReceiptSweepNote(receipt) {
   const finalized = Number(receipt.engine_receipt_sweep?.finalized) || 0;
-  if (!finalized) return '';
-  return `, finalized ${finalized} stale engine receipt${finalized === 1 ? '' : 's'} as presumed dead`;
+  const flights = Number(receipt.fleet_receipt_sweep?.finalized) || 0;
+  const engineNote = finalized ? `, finalized ${finalized} stale engine receipt${finalized === 1 ? '' : 's'} as presumed dead` : '';
+  const fleetNote = flights ? `, marked ${flights} crashed flight${flights === 1 ? '' : 's'} presumed dead` : '';
+  return engineNote + fleetNote;
 }
 
 // Read only: how many ssh-agents look leaked right now, and which readers
@@ -1041,6 +1034,12 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
   } catch (err) {
     receipt.engine_receipt_sweep_error = String((err && err.message) || err).slice(0, 200);
   }
+  try {
+    const fleetSweep = sweepFleetReceipts(root);
+    if (fleetSweep.scanned > 0) receipt.fleet_receipt_sweep = fleetSweep;
+  } catch (err) {
+    receipt.fleet_receipt_sweep_error = String((err && err.message) || err).slice(0, 200);
+  }
 
   runSshAgentSweep(root, receipt);
   runLostRunSweep(root, receipt);

package/commands/autopilot-front.js

@@ -12,6 +12,7 @@ const { wantsJson, hasYesFlag } = require('../lib/noninteractive');
 const { isUnboundScratchFolder, refuseUnboundScratch } = require('../lib/scratch-root');
 const { resolveWorkspaceRoot } = require('../lib/mission-root');
 const { personName } = require('../lib/first-minute');
+const { acquireFileLock } = require('../lib/file-lock');
 
 const CLI_PATH = path.join(__dirname, '..', 'bin', 'atris.js');
 const DEFAULT_LEG_WALL_SECONDS = 3600;
@@ -21,6 +22,7 @@ const MAX_FAST_FAILS = 5;
 
 function statePath(root) { return path.join(root, '.atris', 'state', 'autopilot.json'); }
 function stopPath(root) { return path.join(root, '.atris', 'state', 'autopilot.stop'); }
+function lockPath(root) { return path.join(root, '.atris', 'state', 'autopilot.lock'); }
 
 function readState(root) {
   try { return JSON.parse(fs.readFileSync(statePath(root), 'utf8')); } catch { return null; }
@@ -42,6 +44,26 @@ function requestStop(root) {
 }
 function clearStop(root) { try { fs.unlinkSync(stopPath(root)); } catch {} }
 
+// When `autopilot stop` wrote its marker, in ms, or null without one.
+function stopRequestedAtMs(root) {
+  let stat;
+  try { stat = fs.statSync(stopPath(root)); } catch { return null; }
+  let stamped = NaN;
+  try { stamped = Date.parse(fs.readFileSync(stopPath(root), 'utf8').trim()); } catch {}
+  return Number.isFinite(stamped) ? Math.max(stamped, stat.mtimeMs) : stat.mtimeMs;
+}
+
+// A stop marker left over from before this start is cleared. One written
+// after this process launched is a real stop that raced the start, so it is
+// kept and honored. Returns true when such a stop is pending.
+function clearStaleStop(root, startRequestedAtMs) {
+  const at = stopRequestedAtMs(root);
+  if (at == null) return false;
+  if (at >= startRequestedAtMs) return true;
+  clearStop(root);
+  return false;
+}
+
 function pidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try { process.kill(pid, 0); return true; } catch { return false; }
@@ -261,8 +283,28 @@ async function autopilotFront(args = []) {
     console.log(`Autopilot already running (pid ${existing.pid}). Stop it first: atris autopilot stop`);
     return 1;
   }
+  // The state check above is read-then-write; two starts in the same instant
+  // both passed it. The lock file is created exclusively, so only one wins.
+  const lock = acquireFileLock(lockPath(root));
+  if (!lock.ok) {
+    console.log(`Autopilot already running (pid ${lock.holder?.pid || '?'}). Stop it first: atris autopilot stop`);
+    return 1;
+  }
+  try {
+    return await runFrontLoop(root, args, lock);
+  } finally {
+    lock.release();
+  }
+}
 
-  clearStop(root);
+async function runFrontLoop(root, args, lock) {
+  // The moment this process launched. A stop issued after it is not stale.
+  const startRequestedAtMs = Date.now() - Math.round(process.uptime() * 1000);
+  if (clearStaleStop(root, startRequestedAtMs)) {
+    clearStop(root);
+    console.log('\nAutopilot off (stop requested). Legs run: 0.');
+    return 0;
+  }
   const budgetSeconds = runBudgetSeconds(args);
   const legWallDefault = positiveNumber(readValueFlag(args, '--leg-wall')) || DEFAULT_LEG_WALL_SECONDS;
   // Honor the legacy contract callers still speak: `--iterations=N` caps the
@@ -283,6 +325,8 @@ async function autopilotFront(args = []) {
     console.log(`\nAutopilot off (${reason}). Legs run: ${state.legs}.`);
     clearState(root);
     clearStop(root);
+    // process.exit skips the caller's finally, so release here.
+    try { lock.release(); } catch {}
     process.exit(130);
   };
   process.on('SIGINT', onSignal);
@@ -344,6 +388,7 @@ module.exports = {
   stopRequested,
   requestStop,
   clearStop,
+  clearStaleStop,
   readState,
   writeState,
   watchStopFile,

package/commands/autopilot.js

@@ -1867,24 +1867,41 @@ function isDoPhaseTimeoutMessage(message) {
  * un-struck bullet whose normalized text contains the normalized title
  * prefix; `- **T33:** …` becomes `- [x] **T33:** …`, `- [ ]` becomes `- [x]`.
  * Returns true if a bullet was marked.
+ *
+ * A rendered TODO.md (it carries the "Regenerated from durable Atris task
+ * state" marker) is a view of the task database, so there the job itself is
+ * finished, the way `atris task done` finishes it, and the view re-rendered.
+ * Returns false when no single open or claimed job matches: re-rendering alone
+ * used to return true, and the tick reported a job advanced that never moved.
  */
 function markTodoBulletDone(cwd, taskTitle) {
+  const needle = taskMatchNeedle(taskTitle);
+  let isRenderedView = false;
   try {
-    // A rendered TODO.md carries the "Regenerated from durable Atris task
-    // state" marker; those are projections and never hand-edited. Legacy
-    // hand-written TODO.md files (no marker) keep the bullet-mark fallback.
     const renderedTodoPath = path.join(cwd, 'atris', 'TODO.md');
-    const isRenderedView = fs.existsSync(renderedTodoPath)
+    isRenderedView = fs.existsSync(renderedTodoPath)
       && fs.readFileSync(renderedTodoPath, 'utf8').includes('Regenerated from durable Atris task state');
-    if (isRenderedView) {
+  } catch {
+    isRenderedView = false;
+  }
+  if (isRenderedView) {
+    if (!needle) return false;
+    try {
       require('node:sqlite');
-      const rendered = require('./task').autoRenderTodoFromDb(cwd);
-      if (rendered) return true;
+      const out = require('./task').completeTodoTaskByTitle(cwd, taskTitle, {
+        matches: (title) => {
+          const norm = normalizeForMatch(title);
+          // The reverse test covers a tick title with a prefix ("T33: ..."); a short job title must not match by it.
+          return Boolean(norm) && (norm.includes(needle) || (norm.length >= 12 && needle.includes(norm)));
+        },
+        actor: 'autopilot',
+        proof: `autopilot tick finished "${String(taskTitle || '').slice(0, 200)}" and its completion receipt is in today's journal`,
+      });
+      return Boolean(out && out.completed);
+    } catch {
+      // Older Node runtimes without node:sqlite fall through to the markdown edit.
     }
-  } catch {
-    // Older Node runtimes and legacy workspaces retain the markdown fallback.
   }
-  const needle = taskMatchNeedle(taskTitle);
   if (!needle) return false;
   for (const name of ['TODO.md', 'todo.md']) {
     const todoPath = path.join(cwd, 'atris', name);
@@ -2211,26 +2228,38 @@ function logCompletion(description) {
   ensureLogDirectory();
   const { logFile, dateFormatted } = getLogPath();
 
-  if (!fs.existsSync(logFile)) {
-    createLogFile(logFile, dateFormatted);
-  }
+  // The next C number is read and the entry written as one step under a lock file, so two ticks
+  // finishing at once cannot both take the same number. A lock that cannot be had in a few seconds
+  // does not cost the entry: it is written anyway, as before.
+  const write = () => {
+    if (!fs.existsSync(logFile)) {
+      createLogFile(logFile, dateFormatted);
+    }
 
-  let content = fs.readFileSync(logFile, 'utf8');
+    let content = fs.readFileSync(logFile, 'utf8');
 
-  const completionMatch = content.match(/\*\*C(\d+):/g);
-  const nextId = completionMatch
-    ? Math.max(...completionMatch.map(m => parseInt(m.match(/\d+/)[0]))) + 1
-    : 1;
+    const completionMatch = content.match(/\*\*C(\d+):/g);
+    const nextId = completionMatch
+      ? Math.max(...completionMatch.map(m => parseInt(m.match(/\d+/)[0]))) + 1
+      : 1;
 
-  const entry = `- **C${nextId}:** ${description} [reviewed]`;
+    const entry = `- **C${nextId}:** ${description} [reviewed]`;
 
-  if (content.includes('## Completed')) {
-    content = content.replace(/(## Completed[^\n]*\n)/, `$1\n${entry}\n`);
-  } else {
-    content += `\n## Completed\n\n${entry}\n`;
-  }
+    // Readers look for "## Completed ✅" (and, since this fix, a bare "## Completed" too).
+    if (/^## Completed\b/m.test(content)) {
+      content = content.replace(/^(## Completed[^\n]*\n)/m, `$1\n${entry}\n`);
+    } else {
+      content += `\n## Completed ✅\n\n${entry}\n`;
+    }
 
-  fs.writeFileSync(logFile, content);
+    fs.writeFileSync(logFile, content);
+  };
+  try {
+    require('../lib/handoff-wake').withFileLock(`${logFile}.lock`, write, { staleMs: 60 * 1000, waitMs: 5 * 1000 });
+  } catch (err) {
+    if (!/stayed locked/.test(String(err && err.message))) throw err;
+    write();
+  }
 }
 
 /**
@@ -4055,6 +4084,7 @@ module.exports = {
   diffAdvancedRepoHeads,
   reconcileTimedOutTick,
   markTodoBulletDone,
+  logCompletion,
   findCompletionReceipt,
   isDoPhaseTimeoutMessage,
   validateVerifyCommandShape,

package/commands/clean.js

@@ -359,23 +359,34 @@ function findStaleTasks(atrisDir) {
  * Detects both out-of-bounds AND drift (symbol moved to different line)
  * Returns { healed: number, unhealable: array }
  */
-// The boot map routes; atris/refs/MAP-NOTES.md holds the deep file:line refs.
-// Heal both. Entries from the notes file carry `map` so reports can say where.
+// The boot map routes; atris/refs/MAP-NOTES.md holds the deep file:line refs,
+// or indexes area notes under atris/refs/map/ that hold them. Heal every one.
+// Entries from a notes file carry `map` so reports can say where.
 const MAP_NOTES_FILE = path.join('refs', 'MAP-NOTES.md');
+const MAP_NOTES_DIR = path.join('refs', 'map');
+
+function mapNoteFiles(atrisDir) {
+  const files = [path.join(atrisDir, MAP_NOTES_FILE)];
+  try {
+    for (const name of fs.readdirSync(path.join(atrisDir, MAP_NOTES_DIR)).sort()) {
+      if (name.endsWith('.md')) files.push(path.join(atrisDir, MAP_NOTES_DIR, name));
+    }
+  } catch { /* no area notes */ }
+  return files.filter((file) => { try { return fs.statSync(file).isFile(); } catch { return false; } });
+}
 
 function healBrokenMapRefs(cwd, atrisDir, dryRun = false, homeDir = os.homedir()) {
   const mapFile = path.join(atrisDir, 'MAP.md');
   if (!fs.existsSync(mapFile)) return { healed: 0, unhealable: [] };
   const result = healMapFileRefs(cwd, mapFile, dryRun, homeDir);
-  const notesFile = path.join(atrisDir, MAP_NOTES_FILE);
-  if (!fs.existsSync(notesFile)) return result;
-  const notes = healMapFileRefs(cwd, notesFile, dryRun, homeDir);
-  const map = path.relative(cwd, notesFile).split(path.sep).join('/');
-  return {
-    healed: result.healed + notes.healed,
-    unhealable: [...result.unhealable, ...notes.unhealable.map((entry) => ({ ...entry, map }))],
-    replacements: [...result.replacements, ...notes.replacements.map((entry) => ({ ...entry, map }))],
-  };
+  for (const notesFile of mapNoteFiles(atrisDir)) {
+    const notes = healMapFileRefs(cwd, notesFile, dryRun, homeDir);
+    const map = path.relative(cwd, notesFile).split(path.sep).join('/');
+    result.healed += notes.healed;
+    result.unhealable = [...result.unhealable, ...notes.unhealable.map((entry) => ({ ...entry, map }))];
+    result.replacements = [...(result.replacements || []), ...notes.replacements.map((entry) => ({ ...entry, map }))];
+  }
+  return result;
 }
 
 function healMapFileRefs(cwd, mapFile, dryRun, homeDir) {

package/commands/computer.js

@@ -2105,7 +2105,7 @@ async function runComputer(argv = process.argv.slice(3), deps = {}) {
     console.log('  atris computer local');
     console.log('  atris computer codex');
     console.log('  atris computer --cloud');
-    console.log('  atris computer --cloud --worker openai --model gpt-5.4');
+    console.log('  atris computer --cloud --worker openai --model <model>');
     console.log('  atris computer cloud');
     console.log('  atris computer codeops');
     console.log('  atris computer codeops status');

package/commands/doc-health.js

@@ -5,6 +5,7 @@ const path = require('path');
 const { resolveWorkspaceRoot } = require('../lib/mission-root');
 const { readText } = require('./brain');
 const { checkMapDocs, fixMapDocs } = require('../lib/map-refs');
+const { runRecallExam } = require('../lib/recall-exam');
 
 const BOOT_FILES = [
   'CLAUDE.md', 'AGENTS.md', 'atris/atris.md', 'atris/MAP.md',
@@ -357,12 +358,58 @@ function renderDocHealth(payload) {
   return lines.join('\n');
 }
 
+function flagValue(args, name) {
+  const index = args.indexOf(name);
+  if (index >= 0 && args[index + 1] && !args[index + 1].startsWith('--')) return args[index + 1];
+  return args.find(arg => arg.startsWith(`${name}=`))?.slice(name.length + 1);
+}
+
+function renderRecall(report, summaryOnly) {
+  const pct = value => (value === null ? 'n/a' : `${Math.round(value * 100)}%`);
+  const lines = [
+    `recall exam: ${report.found}/${report.questions} found (${pct(report.found_share)})`,
+    `boot read first: ${report.boot_tokens} tokens`,
+    `files opened after boot: median ${report.files_opened.median}, mean ${report.files_opened.mean === null ? 'n/a' : report.files_opened.mean.toFixed(2)}`,
+    `wrong opens (opened but not on the path to the answer): total ${report.wrong_opens.total}, mean ${report.wrong_opens.mean === null ? 'n/a' : report.wrong_opens.mean.toFixed(2)}`,
+    `tokens opened after boot: median ${report.tokens_opened.median}, mean ${report.tokens_opened.mean}, median when found ${report.tokens_opened_when_found.median}`,
+    ...table(['area', 'found', 'total'], Object.entries(report.by_area).sort().map(([area, row]) => [area, row.found, row.total])),
+  ];
+  if (report.invalid_lines.length) lines.push(`invalid question lines skipped: ${report.invalid_lines.join(', ')}`);
+  if (!summaryOnly) {
+    lines.push('', ...table(['id', 'found', 'opened', 'wrong', 'tokens', 'answer in'],
+      report.results.map(row => [row.id || '-', row.found ? 'yes' : 'no', row.files_opened, row.wrong_opens, row.tokens_opened, row.found_in || '-'])));
+  }
+  return lines.join('\n');
+}
+
+function recallCommand(args, options, file) {
+  const root = resolveWorkspaceRoot(options.cwd || process.cwd());
+  const questionsFile = path.resolve(options.cwd || process.cwd(), file);
+  if (!stat(questionsFile)?.isFile()) {
+    console.log(`no recall questions at ${file}. one object per line: {"q":"...","needle":"exact answer phrase"}`);
+    return 1;
+  }
+  const maxOpens = Number(flagValue(args, '--max-opens')) || undefined;
+  const report = runRecallExam(root, questionsFile, { bootFiles: BOOT_FILES, maxOpens });
+  // A held-out set is scored without echoing its questions back to the improver.
+  const summaryOnly = args.includes('--summary');
+  if (args.includes('--json')) {
+    const { results, ...totals } = report;
+    console.log(JSON.stringify({ ok: true, action: 'doc-health recall', ...totals, ...(summaryOnly ? {} : { results }) }, null, 2));
+  } else console.log(renderRecall(report, summaryOnly));
+  return 0;
+}
+
 function docHealthCommand(args = [], options = {}) {
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
-    console.log('usage: atris doc-health [--json] [--questions <path>] [--fix-refs]');
+    console.log('usage: atris doc-health [--json] [--questions <path>] [--fix-refs] [--recall <path> [--summary] [--max-opens N]]');
     console.log('  --fix-refs  rewrite map line refs whose code moved; list the ones a human must fix');
+    console.log('  --recall    follow links from the boot files to answer each question; report found, files opened, tokens read');
+    console.log('  --summary   with --recall, print totals only so a held-out set stays unseen');
     return 0;
   }
+  const recallFile = flagValue(args, '--recall');
+  if (recallFile) return recallCommand(args, options, recallFile);
   if (args.includes('--fix-refs')) {
     const root = resolveWorkspaceRoot(options.cwd || process.cwd());
     if (!stat(path.join(root, 'atris', 'MAP.md'))?.isFile()) {

package/commands/improve.js

@@ -96,6 +96,7 @@ function parseImproveArgs(argv = []) {
     timeoutMs: DEFAULT_TIMEOUT_MS,
     help: false,
     history: false,
+    unknownCommand: null,
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -113,6 +114,7 @@ function parseImproveArgs(argv = []) {
     if (a.startsWith('--timeout=')) { const v = Number(a.split('=')[1]); if (v > 0) opts.timeoutMs = Math.round(v * 1000); continue; }
     // positional mode (plan|full|delegate)
     if (!a.startsWith('-') && VALID_MODES.has(a)) { opts.mode = a; continue; }
+    if (i === 0 && !a.startsWith('-')) { opts.unknownCommand = a; continue; }
   }
 
   if (!VALID_MODES.has(opts.mode)) opts.mode = 'full';
@@ -300,7 +302,7 @@ function formatTickHistory(summary = {}) {
   if (summary.rewardTrend && summary.rewardTrend.length) {
     lines.push(`  trend:    ${summary.rewardTrend.map((r) => (r == null ? '·' : r)).join(' → ')}`);
   }
-  if (!summary.ticks) lines.push('  (no ticks yet, run `atris improve`)');
+  if (!summary.ticks) lines.push('  (no ticks yet, run `atris improve tick`)');
   return lines.join('\n');
 }
 
@@ -1049,6 +1051,7 @@ const REVISION_WINDOW_HOURS = 72;
 const REVISION_IGNORED_FILES = [
   /^atris\/MAP\.md$/,
   /^atris\/refs\/MAP-NOTES\.md$/,
+  /^atris\/refs\/map\/[^/]+\.md$/,
   /^test\/fast-tests\.txt$/,
   /^atris\/logs\//,
   /^atris\/runs\//,
@@ -1507,7 +1510,7 @@ Modes (positional or --mode):
 
 Options:
   --member <name>  attribute the tick to a member (the loop's owner)
-  --model <id>     override the model (e.g. claude-sonnet-4-6)
+  --model <id>     override the model (e.g. sonnet)
   --dry-run        plan and run but do not commit
   --no-fallback    do not fall back to a local tick if the backend is down
   --workspace <p>  workspace path (default: cwd)
@@ -1523,7 +1526,11 @@ the backend is unreachable or you are not logged in.`);
 }
 
 function isBareVitalsArgs(argv = []) {
-  return argv.length === 0 || (argv.length === 1 && argv[0] === '--json');
+  if (argv.length === 0 || (argv.length === 1 && argv[0] === '--json')) return true;
+  if (argv[0] === 'status' || argv[0] === 'vitals') {
+    return argv.length === 1 || (argv.length === 2 && argv[1] === '--json');
+  }
+  return false;
 }
 
 const LOOP_DOCTOR_OPEN_STATUSES = new Set(['planning', 'ready', 'running', 'paused', 'blocked']);
@@ -1693,6 +1700,12 @@ async function run(argv = [], deps = {}) {
   const routedArgs = args[0] === 'tick' ? args.slice(1) : args;
   const opts = parseImproveArgs(routedArgs);
   if (opts.help) { showHelp(); return 0; }
+  if (opts.unknownCommand) {
+    const error = `unknown improve subcommand "${opts.unknownCommand}". try: atris improve, atris improve tick, atris improve history, atris improve doctor, or atris improve revisions.`;
+    if (opts.json) console.log(JSON.stringify({ ok: false, error, subcommand: opts.unknownCommand }));
+    else console.error(error);
+    return 1;
+  }
 
   if (opts.history) {
     const summary = summarizeTickHistory(readTickHistory(opts.workspace));

package/commands/init.js

@@ -1,4 +1,5 @@
 const fs = require('fs');
+const { ensureProjectTasteFile } = require('../lib/taste-notes');
 const path = require('path');
 const { ensureMemberBundle } = require('../lib/member-scaffold');
 const { ensureExperimentsFramework } = require('./experiments');
@@ -507,6 +508,9 @@ function initAtris() {
     markReady('workspace', 'lessons.md', '✓ Created lessons.md');
   }
 
+  // Project taste starts empty and is never overwritten; sync leaves it alone.
+  if (ensureProjectTasteFile(targetDir)) markReady('workspace', 'taste/TASTE.md', '✓ Created taste/TASTE.md');
+
   // Create features directory and README
   const featuresDir = path.join(targetDir, 'features');
   const templatesDir = path.join(featuresDir, '_templates');