atris 3.68.1 → 3.68.3

package/commands/done.js

@@ -0,0 +1,374 @@
+'use strict';
+
+// `atris done`: the one command a person runs after their coding agent built
+// the thing. It names what was built, lands it through the real task path
+// (`task ready --verify` then `task accept`, same gates agents face), and ends
+// with a short credits roll and the file to open.
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { argsWantHelp } = require('../lib/noninteractive');
+const {
+  buildFirstMinute,
+  firstTalkBuildCommand,
+  firstTalkBuilder,
+  folderName,
+  humanStarterTask,
+  isFreshWorkspace,
+  listBuiltSince,
+  loadLocalTasks,
+  mainBuiltFile,
+  orderBuilt,
+  personName,
+  speakFirstMinute,
+  spokenBuiltList,
+  taskStartedAt,
+} = require('../lib/first-minute');
+
+const ATRIS_BIN = path.join(__dirname, '..', 'bin', 'atris.js');
+const DONE_SCHEMA = 'atris.one_lap.v1';
+
+// What a page has, in plain words, for the first tag found.
+const HTML_MARKS = [
+  ['<form', 'the form'],
+  ['<h1', 'the heading'],
+  ['<title', 'the page title'],
+  ['<main', 'the main section'],
+  ['<body', 'the page body'],
+  ['<html', 'the page'],
+];
+
+function doneUsage() {
+  return 'Usage: atris done [<task>] [--json]';
+}
+
+function shQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function spokenTitle(task) {
+  return String((task && task.title) || 'this').replace(/\s+/g, ' ').trim().replace(/[.,;:!?]+$/g, '');
+}
+
+function readHead(root, file) {
+  try {
+    const buf = fs.readFileSync(path.join(root, file));
+    return buf.subarray(0, 65536);
+  } catch {
+    return null;
+  }
+}
+
+// A check that fails when the built file is gone or no longer holds what was
+// built, so it clears the weak-verifier and empty-folder gates honestly.
+function verifierFor(root, files) {
+  const ordered = orderBuilt(files);
+  for (const file of ordered) {
+    const head = readHead(root, file);
+    if (!head || !head.length || head.includes(0)) continue;
+    const text = head.toString('utf8');
+    if (/\.html?$/i.test(file)) {
+      const lower = text.toLowerCase();
+      const mark = HTML_MARKS.find(([tag]) => lower.includes(tag));
+      if (mark) {
+        return {
+          command: `grep -qi ${shQuote(mark[0])} ${shQuote(file)}`,
+          plain: `${file} has ${mark[1]}`,
+          file,
+        };
+      }
+    }
+    const word = (text.match(/[A-Za-z][A-Za-z0-9_-]{3,}/) || [])[0];
+    if (word) {
+      return {
+        command: `grep -qF ${shQuote(word)} ${shQuote(file)}`,
+        plain: `${file} says "${word}"`,
+        file,
+      };
+    }
+  }
+  const file = ordered.find((name) => {
+    const head = readHead(root, name);
+    return head && head.length;
+  });
+  if (!file) return null;
+  return {
+    command: `grep -qa . ${shQuote(file)}`,
+    plain: `${file} is there and not empty`,
+    file,
+  };
+}
+
+// One sentence the ready gate accepts: what the person can do now and why.
+function resultSentence(task) {
+  const { explainResult } = require('../lib/autoland');
+  const title = spokenTitle(task).replace(/[.!?]/g, '').slice(0, 100).trim();
+  const candidates = [
+    `You can now open ${title} and use it yourself, so it is real instead of only a plan.`,
+    'You can now open what you asked for here and use it yourself, so it is real instead of only a plan.',
+  ];
+  return candidates.find((line) => explainResult(line, { allowCommandMention: true }).ok) || candidates[1];
+}
+
+function openCommand(file) {
+  const target = /^[\w./-]+$/.test(file) ? file : shQuote(file);
+  if (process.platform === 'darwin') return `open ${target}`;
+  if (process.platform === 'win32') return `start ${target}`;
+  return `xdg-open ${target}`;
+}
+
+function buildCommandFor(task, builder) {
+  const pick = builder !== undefined ? builder : firstTalkBuilder();
+  // Test runners skip the machine probe; name the default builder so the line stays runnable.
+  return firstTalkBuildCommand(pick === undefined ? 'claude' : pick, spokenTitle(task));
+}
+
+function taskRefOf(task) {
+  return String((task && (task.display_id || task.legacy_ref || task.id)) || '').trim();
+}
+
+function findTask(tasks, ref) {
+  const want = String(ref || '').trim().toLowerCase();
+  if (!want) return null;
+  return tasks.find((task) => [task.display_id, task.legacy_ref, task.id]
+    .some((value) => value && String(value).toLowerCase() === want))
+    || tasks.find((task) => task.id && String(task.id).toLowerCase().startsWith(want))
+    || null;
+}
+
+function pickTask(tasks, person) {
+  const starter = humanStarterTask(tasks, person);
+  if (starter) return starter;
+  const who = String(person || '').trim();
+  const mine = tasks
+    .filter((task) => (task.status === 'claimed' || task.status === 'review')
+      && (!who || String(task.claimed_by || '') === who))
+    .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0));
+  return mine[0] || null;
+}
+
+function runAtris(root, args) {
+  const result = spawnSync(process.execPath, [ATRIS_BIN, ...args], {
+    cwd: root,
+    env: process.env,
+    encoding: 'utf8',
+    timeout: 240000,
+  });
+  let json = null;
+  try {
+    json = JSON.parse(String(result.stdout || '').trim());
+  } catch {
+    json = null;
+  }
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: String(result.stdout || ''),
+    stderr: String(result.stderr || ''),
+    json,
+  };
+}
+
+function failureLine(step) {
+  const text = `${step.stderr}\n${step.stdout}`;
+  if (step.json && (step.json.detail || step.json.reason)) {
+    return String(step.json.detail || step.json.reason).split('\n')[0];
+  }
+  const line = text.split('\n').map((s) => s.trim()).find(Boolean);
+  return line || `exit ${step.status}`;
+}
+
+function liveTask(root, id) {
+  try {
+    const taskDb = require('../lib/task-db');
+    const db = taskDb.open();
+    return taskDb.getTask(db, id);
+  } catch {
+    return null;
+  }
+}
+
+function receiptFromProof(proof) {
+  const match = String(proof || '').match(/Receipt:\s*(\S+\.json)/);
+  return match ? match[1] : '';
+}
+
+// The receipt is the record. Say on it that the person who owned this work
+// accepted it themselves, through `atris done`.
+function stampOwnerAccept(root, receiptPath, { owner, actor }) {
+  if (!receiptPath) return false;
+  const file = path.resolve(root, receiptPath);
+  try {
+    const receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
+    receipt.accepted = {
+      by: actor || owner || null,
+      owner: owner || null,
+      self_accepted: true,
+      via: 'atris done',
+      note: 'the human owner accepted their own work',
+      at: new Date().toISOString(),
+    };
+    fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function renderCredits({ title, built, checked, receipt, next }) {
+  return [
+    '',
+    `  ${title}`,
+    '',
+    `  built     ${spokenBuiltList(built)}`,
+    `  checked   ${checked}, passed`,
+    `  signed    ${receipt || 'the task record'}`,
+    '',
+    `next: ${next}`,
+  ].join('\n');
+}
+
+function emit(asJson, log, payload, text) {
+  if (asJson) log(JSON.stringify(payload, null, 2));
+  else log(text);
+}
+
+function doneAtris(args = process.argv.slice(3), {
+  root = process.cwd(),
+  log = console.log,
+  builder,
+} = {}) {
+  const list = Array.isArray(args) ? args : [];
+  if (argsWantHelp(list)) {
+    log(doneUsage());
+    return 0;
+  }
+  const asJson = list.includes('--json');
+  const ref = list.find((arg) => !String(arg).startsWith('-')) || '';
+
+  if (isFreshWorkspace(root)) {
+    return speakFirstMinute({ root, fresh: true, asJson, log });
+  }
+
+  const person = personName();
+  const tasks = loadLocalTasks(root);
+  const task = ref ? findTask(tasks, ref) : pickTask(tasks, person);
+
+  if (!task) {
+    const minute = buildFirstMinute({ root, builder });
+    const reason = ref ? `nothing here is called ${ref}` : 'nothing of yours is in progress here';
+    // Already shipped: say so, the same way bare atris does.
+    const text = !ref && minute.shipped ? `\n${minute.text}` : `\n${reason}.\n\nnext: ${minute.nextCommand}`;
+    emit(asJson, log, {
+      schema: DONE_SCHEMA,
+      ok: false,
+      status: 'stuck',
+      reason,
+      next_action: minute.nextCommand,
+    }, text);
+    return asJson ? 2 : 0;
+  }
+
+  const title = spokenTitle(task);
+  if (task.status === 'done') {
+    emit(asJson, log, {
+      schema: DONE_SCHEMA,
+      ok: true,
+      status: 'already_done',
+      reason: `${title} is already done`,
+      next_action: buildFirstMinute({ root, builder }).nextCommand,
+    }, `\n${title} is already done.\n\nnext: ${buildFirstMinute({ root, builder }).nextCommand}`);
+    return 0;
+  }
+  if (!['open', 'claimed', 'review'].includes(task.status)) {
+    emit(asJson, log, {
+      schema: DONE_SCHEMA,
+      ok: false,
+      status: 'stuck',
+      reason: `${title} is ${task.status}`,
+      next_action: `atris task show ${taskRefOf(task)}`,
+    }, `\n${title} is ${task.status}.\n\nnext: atris task show ${taskRefOf(task)}`);
+    return asJson ? 2 : 0;
+  }
+
+  const built = orderBuilt(listBuiltSince(root, taskStartedAt(task)));
+  if (!built.length) {
+    const next = buildCommandFor(task, builder);
+    emit(asJson, log, {
+      schema: DONE_SCHEMA,
+      ok: true,
+      status: 'nothing_new',
+      reason: `nothing new here since you started ${title}`,
+      task: { display_id: task.display_id || null, title: task.title },
+      built: [],
+      next_action: next,
+    }, `\nnothing new here since you started ${title}.\n\nnext: ${next}`);
+    return 0;
+  }
+
+  const verify = verifierFor(root, built);
+  const fail = (reason, next) => {
+    emit(asJson, log, {
+      schema: DONE_SCHEMA,
+      ok: false,
+      status: 'stuck',
+      reason,
+      task: { display_id: task.display_id || null, title: task.title },
+      built,
+      next_action: next,
+    }, `\n${title} has new work, but ${reason}.\n\nnext: ${next}`);
+    return 1;
+  };
+  if (!verify) return fail('nothing built has content to check yet', buildCommandFor(task, builder));
+
+  let current = liveTask(root, task.id) || task;
+  if (current.status !== 'review') {
+    const ready = runAtris(root, [
+      'task', 'ready', task.id,
+      '--verify', verify.command,
+      '--result', resultSentence(task),
+      '--json',
+    ]);
+    if (!ready.ok) {
+      return fail(`the check did not pass (${failureLine(ready)})`, `atris task show ${taskRefOf(task)}`);
+    }
+    current = liveTask(root, task.id) || current;
+  }
+  const receipt = receiptFromProof(current && current.metadata && current.metadata.latest_agent_proof);
+
+  const accept = runAtris(root, ['task', 'accept', task.id, '--json']);
+  if (!accept.ok) {
+    const why = failureLine(accept);
+    const waiting = /agent_proof_only|cannot accept/i.test(`${why} ${accept.stderr} ${accept.stdout}`);
+    return fail(
+      waiting ? 'it is checked and waiting on a person to accept it' : `accept did not go through (${why})`,
+      `atris task accept ${taskRefOf(task)}`,
+    );
+  }
+  const actor = (accept.json && accept.json.episode && (accept.json.episode.actor || accept.json.episode.reviewer)) || '';
+  const stamped = stampOwnerAccept(root, receipt, { owner: task.claimed_by || person, actor });
+
+  const main = mainBuiltFile(built);
+  const next = openCommand(main);
+  emit(asJson, log, {
+    schema: DONE_SCHEMA,
+    ok: true,
+    status: 'done',
+    reason: `${title} is done`,
+    task: { display_id: task.display_id || null, title: task.title },
+    built,
+    checked: { command: verify.command, plain: verify.plain, passed: true },
+    receipt: receipt || null,
+    owner_accepted: stamped,
+    next_action: next,
+  }, renderCredits({ title, built, checked: verify.plain, receipt, next }));
+  return 0;
+}
+
+module.exports = {
+  doneAtris,
+  resultSentence,
+  verifierFor,
+  openCommand,
+};

package/commands/engine.js

@@ -38,7 +38,7 @@ const { teamRosterView } = require('../lib/member-engine');
 const { engineModelText, engineRunsView, availableModels, modelLabel } = require('../lib/roster-models');
 const { renderTable } = require('../lib/text-table');
 const { TEAM_FOOTER } = require('../lib/team-lineup');
-const { readRosterRuns, workerRuns, summarizeRuns, recentRuns, renderRunLine, DEFAULT_DAYS: RUN_DAYS } = require('../lib/roster-runs');
+const { readRosterRuns, workerRuns, summarizeRuns, recentRuns, renderRunLine, runView, DEFAULT_DAYS: RUN_DAYS } = require('../lib/roster-runs');
 const { attachSuggestions } = require('../lib/roster-suggest');
 const { PIN_MAX_AGE_DAYS: PIN_STALE_DAYS, attachStaleModels, modelCatalog } = require('../lib/roster-stale');
 const {
@@ -1507,7 +1507,7 @@ const RUNS_LIST_LIMIT = 20;
 function runRosterRunsCommand(job, json, root, now) {
   const runs = recentRuns(readRosterRuns(root, { now, days: RUNS_LIST_DAYS }), { job, limit: RUNS_LIST_LIMIT });
   if (json) {
-    console.log(JSON.stringify({ job: job || null, days: RUNS_LIST_DAYS, runs }, null, 2));
+    console.log(JSON.stringify({ job: job || null, days: RUNS_LIST_DAYS, runs: runs.map(runView) }, null, 2));
     return 0;
   }
   if (!runs.length) {

package/commands/goal.js

@@ -168,9 +168,65 @@ function renderGoalView(view) {
   return lines.join('\n');
 }
 
+// A goal that never becomes a mission run is a wish. `goal set` therefore also
+// files the sentence through the normal wish capture path (capture only: no
+// mission, no driver), so the goal -> wish -> mission -> run chain starts here.
+// Wish capture is best-effort: it must never fail or undo the goal itself.
+function wishNextStep(wish, goal) {
+  return wish.status === 'needs_input'
+    ? 'atris wish answer "your words"'
+    : `atris wish again ${wish.id} "${goal}"`;
+}
+
+function captureGoalWish(sentence, root) {
+  const goal = String(sentence || '').replace(/\s+/g, ' ').trim();
+  const { isFreshWorkspace } = require('../lib/first-minute');
+  if (isFreshWorkspace(root)) {
+    console.error('note: wish not filed, no atris/ workspace here. run: atris init');
+    return null;
+  }
+  const previous = process.cwd();
+  let wish = null;
+  try {
+    if (previous !== root) process.chdir(root);
+    // Re-setting the same goal must not stack duplicate wishes.
+    const { readWishes } = require('../lib/wish-store');
+    const open = readWishes(root).find((w) => (
+      normalizeText(w.text) === normalizeText(goal)
+      && ['captured', 'captured_no_mission', 'needs_input'].includes(w.status)
+    ));
+    if (open) {
+      console.log(`wish already filed: ${open.id}`);
+      console.log(`next      ${wishNextStep(open, goal)}`);
+      return open;
+    }
+    const { runCapturedWish } = require('../lib/wish-delegate');
+    runCapturedWish(goal, root, {
+      noMission: true,
+      afterCapture: (captured) => { wish = captured; },
+    });
+  } catch (error) {
+    console.error(`warning: goal set, but wish capture failed: ${normalizeText(error?.message || error)}`);
+    return null;
+  } finally {
+    if (process.cwd() !== previous) process.chdir(previous);
+  }
+  if (!wish) return null;
+  let latest = wish;
+  try {
+    const { readWishes } = require('../lib/wish-store');
+    latest = readWishes(root).find((w) => w.id === wish.id) || wish;
+  } catch {
+    latest = wish;
+  }
+  console.log(`wish id   ${wish.id}`);
+  console.log(`next      ${wishNextStep(latest, goal)}`);
+  return latest;
+}
+
 function printHelp() {
   console.log('usage: atris goal [--json]');
-  console.log('       atris goal set "<sentence>"');
+  console.log('       atris goal set "<sentence>" [--no-wish]');
   console.log('       atris goal metric <name> <value>');
   console.log('       atris goal metric <name> --rm');
 }
@@ -187,7 +243,9 @@ function run(args = [], context = {}) {
     }
 
     if (command === 'set') {
-      const goal = normalizeText(args.slice(1).join(' '));
+      const noWish = args.includes('--no-wish');
+      const sentence = args.slice(1).filter((arg) => arg !== '--no-wish').join(' ');
+      const goal = normalizeText(sentence);
       if (!goal) {
         console.error('error: goal sentence is required');
         return 2;
@@ -195,6 +253,7 @@ function run(args = [], context = {}) {
       const scoreboard = readScoreboard(root);
       writeScoreboard({ ...scoreboard, goal }, root);
       console.log('goal set.');
+      if (!noWish) captureGoalWish(sentence, root);
       return 0;
     }
 

package/commands/land.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const gitSpawn = require('../lib/git-spawn');
 const { compactErrorPayload, printCliJson } = require('../lib/cli-json');
-const { listWorktrees, statusCounts } = require('./worktree');
+const { listWorktrees, statusCounts, defaultMainlineBase, listActiveProcessCwds, worktreeHasActiveProcess, recordWorktreeRemoval } = require('./worktree');
 
 const DEFAULT_TTL_DAYS = 7;
 const DEFAULT_STALE_HOURS = 48;
@@ -38,10 +38,11 @@ function refExists(root, ref) {
 
 function baseBranch(root, override = '') {
   if (override && refExists(root, override)) return override;
-  if (refExists(root, 'origin/master')) return 'origin/master';
-  if (refExists(root, 'origin/main')) return 'origin/main';
-  if (refExists(root, 'master')) return 'master';
-  if (refExists(root, 'main')) return 'main';
+  const mainline = defaultMainlineBase(root);
+  if (mainline !== 'HEAD') return mainline;
+  for (const candidate of ['main', 'master']) {
+    if (refExists(root, candidate)) return candidate;
+  }
   return '';
 }
 
@@ -309,7 +310,7 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
   const cherryCache = loadCherryCache(root);
   const baseSha = resolveSha(root, base);
   for (const branch of listBranches(root, base)) {
-    if (PROTECTED_BRANCHES.has(branch.name)) continue;
+    if (PROTECTED_BRANCHES.has(branch.name) || branch.name === base.replace(/^origin\//, '')) continue;
     const lastCommitMs = Number(branch.lastCommitUnix) * 1000;
     if (Number.isFinite(lastCommitMs)) lastCommitMsByBranch.set(branch.name, lastCommitMs);
     const ahead = branch.ahead !== undefined ? branch.ahead : aheadCount(root, base, branch.name);
@@ -527,6 +528,15 @@ function salvageWorktree(w, dir, receipt) {
   }
 }
 
+function reapReason(w, board, ttlDays, force) {
+  const state = (board.branches.find((b) => b.name === w.branch) || {}).state;
+  if (state === 'landed') return 'branch_landed';
+  if (state === 'due') return 'branch_past_ttl';
+  if (w.state === 'detached') return 'detached_head';
+  if (typeof w.ageDays === 'number' && w.ageDays > ttlDays) return 'worktree_past_ttl';
+  return force ? 'forced' : 'unlanded_commits';
+}
+
 // Reap: salvage then delete everything landed (residue) or past TTL.
 // Salvage first, always: unlanded commits go into a git bundle, dirty
 // worktrees into patch files + untracked-file copies, so a reap is never
@@ -534,7 +544,9 @@ function salvageWorktree(w, dir, receipt) {
 // includeDetached: detached-HEAD worktrees have no branch, so the salvage
 // bundle cannot cover their commits, unattended reaps (autoland) pass false
 // and leave them for a human reap.
-function reap(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOURS, base: baseOverride = '', dryRun = false, remote = true, includeDetached = true, protectCurrent = true, force = false, now = Date.now() } = {}) {
+function reap(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOURS, base: baseOverride = '', dryRun = false, remote = true, includeDetached = true, protectCurrent = true, force = false, now = Date.now(), activeCwds: activeCwdsOverride, by = 'atris land --reap' } = {}) {
+  const readActiveCwds = () => (Array.isArray(activeCwdsOverride) ? activeCwdsOverride : listActiveProcessCwds());
+  let activeCwds = null;
   const board = collectBoard(root, { ttlDays, staleHours, base: baseOverride, now });
   const targets = board.branches.filter((b) => b.state === 'landed' || b.state === 'due');
   const targetNames = new Set(targets.map((b) => b.name));
@@ -554,6 +566,13 @@ function reap(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOU
       protectedWorktrees.push({ ...w, reason: 'current_checkout' });
       continue;
     }
+    // A run working inside the folder outranks --force: removing it pulls
+    // the floor out from under a live engine.
+    if (!activeCwds) activeCwds = readActiveCwds();
+    if (worktreeHasActiveProcess(w.path, activeCwds)) {
+      protectedWorktrees.push({ ...w, reason: 'active_process' });
+      continue;
+    }
     if (worktreeWithinReapGrace(w.path, now)) {
       protectedWorktrees.push({ ...w, reason: 'fresh_worktree_grace' });
       continue;
@@ -642,7 +661,14 @@ function reap(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOU
   const survivingWorktreeTargets = worktreeTargets.filter(
     (w) => targetNames.has(w.branch) || (includeDetached && w.state === 'detached')
   );
+  const activeAtRemoval = survivingWorktreeTargets.length ? readActiveCwds() : [];
   for (const w of survivingWorktreeTargets) {
+    // A run can start in the folder while the bundle is built; look again.
+    if (worktreeHasActiveProcess(w.path, activeAtRemoval)) {
+      receipt.keptWorktrees.push(`${w.path} (active_process)`);
+      if (w.branch) targetNames.delete(w.branch);
+      continue;
+    }
     // The grace check ran at scan time, and a bundle build can sit between it
     // and removal — an engine that booted mid-sweep refreshes the directory
     // mtime in that gap. Stat once more at removal time, the cheapest place
@@ -665,6 +691,7 @@ function reap(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOU
     const removed = runGit(['worktree', 'remove', '--force', w.path], { cwd: root, check: false });
     if (removed.status === 0) {
       receipt.removedWorktrees.push(w.path);
+      recordWorktreeRemoval(root, { path: w.path, branch: w.branch, by, reason: reapReason(w, board, ttlDays, force) });
     } else {
       // A locked worktree fails here and, unreported, reap re-salvages the
       // same patches every pass forever. Say what blocked it so a human can