atris 3.33.3 → 3.35.0

package/commands/land.js

@@ -5,6 +5,7 @@ const { spawnSync } = require('child_process');
 const { listWorktrees, statusCounts } = require('./worktree');
 
 const DEFAULT_TTL_DAYS = 7;
+const WORKTREE_REAP_GRACE_MS = 60 * 60 * 1000;
 const PROTECTED_BRANCHES = new Set(['main', 'master']);
 
 function runGit(args, { cwd = process.cwd(), check = true } = {}) {
@@ -36,6 +37,19 @@ function ageDays(unixSeconds, now = Date.now()) {
   return Math.floor((now / 1000 - Number(unixSeconds)) / 86400);
 }
 
+function worktreeMtimeMs(worktreePath) {
+  try {
+    return fs.statSync(worktreePath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+
+function worktreeWithinReapGrace(worktreePath, now = Date.now()) {
+  const mtime = worktreeMtimeMs(worktreePath);
+  return typeof mtime === 'number' && now - mtime < WORKTREE_REAP_GRACE_MS;
+}
+
 function listBranches(root) {
   const result = runGit(
     ['for-each-ref', 'refs/heads', '--format=%(refname:short)%09%(committerdate:unix)'],
@@ -146,16 +160,67 @@ function remoteHeads(root) {
   return heads;
 }
 
+// Everything a force-remove would destroy: staged + unstaged tracked changes
+// (git diff HEAD) and untracked files (copied verbatim). Returns false if any
+// piece could not be saved — the caller then keeps the worktree.
+function salvageWorktree(w, dir, receipt) {
+  try {
+    const diff = runGit(['diff', 'HEAD'], { cwd: w.path, check: false });
+    if (diff.status !== 0) return false;
+    if (diff.stdout.trim()) {
+      const patchPath = path.join(dir, `${path.basename(w.path)}.dirty.patch`);
+      fs.writeFileSync(patchPath, diff.stdout);
+      receipt.patches.push(patchPath);
+    }
+    const untracked = runGit(['ls-files', '--others', '--exclude-standard', '-z'], { cwd: w.path, check: false });
+    if (untracked.status !== 0) return false;
+    const files = untracked.stdout.split('\0').filter(Boolean);
+    if (files.length > 0) {
+      const destRoot = path.join(dir, `${path.basename(w.path)}.untracked`);
+      for (const rel of files) {
+        const dest = path.join(destRoot, rel);
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.copyFileSync(path.join(w.path, rel), dest);
+      }
+      receipt.untracked.push(destRoot);
+    }
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
 // 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, so a reap is never a loss of work.
-function reap(root, { ttlDays = DEFAULT_TTL_DAYS, base: baseOverride = '', dryRun = false, remote = true } = {}) {
+// worktrees into patch files + untracked-file copies, so a reap is never
+// a loss of work — and when a backup cannot be written, the work stays.
+// 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, base: baseOverride = '', dryRun = false, remote = true, includeDetached = true } = {}) {
   const board = collectBoard(root, { ttlDays, base: baseOverride });
   const targets = board.branches.filter((b) => b.state === 'landed' || b.state === 'due');
   const targetNames = new Set(targets.map((b) => b.name));
-  const worktreeTargets = board.worktrees.filter(
-    (w) => targetNames.has(w.branch) || w.state === 'detached' || (typeof w.ageDays === 'number' && w.ageDays > ttlDays)
+  const candidateWorktrees = board.worktrees.filter(
+    (w) => targetNames.has(w.branch) || (includeDetached && w.state === 'detached') || (typeof w.ageDays === 'number' && w.ageDays > ttlDays)
   );
+  const protectedWorktrees = [];
+  const worktreeTargets = [];
+  for (const w of candidateWorktrees) {
+    // Only the fresh-worktree grace protects here. Dirty worktrees are NOT
+    // skipped: reap's salvage (bundle + patches + untracked copies below)
+    // exists precisely so dirty residue can be cleared loss-free. Blanket
+    // dirty protection lives in the janitor's cleanupWorktrees, which has
+    // no salvage machinery.
+    if (worktreeWithinReapGrace(w.path)) {
+      protectedWorktrees.push({ ...w, reason: 'fresh_worktree_grace' });
+      continue;
+    }
+    worktreeTargets.push(w);
+  }
+  for (const w of protectedWorktrees) {
+    if (w.branch) targetNames.delete(w.branch);
+  }
   for (const w of worktreeTargets) {
     if (w.branch && !targetNames.has(w.branch)) targetNames.add(w.branch);
   }
@@ -165,7 +230,11 @@ function reap(root, { ttlDays = DEFAULT_TTL_DAYS, base: baseOverride = '', dryRu
     ttlDays,
     dryRun,
     bundle: null,
+    bundleError: null,
     patches: [],
+    untracked: [],
+    keptWorktrees: protectedWorktrees.map((w) => `${w.path} (${w.reason})`),
+    keptMovedBranches: [],
     removedWorktrees: [],
     deletedBranches: [],
     deletedRemote: [],
@@ -190,22 +259,50 @@ function reap(root, { ttlDays = DEFAULT_TTL_DAYS, base: baseOverride = '', dryRu
       check: false,
     });
     if (result.status === 0) receipt.bundle = bundlePath;
+    else {
+      // Salvage-first is a hard promise: no bundle, no deletion of unlanded
+      // work. These branches (and their worktrees) survive until a reap can
+      // actually back them up.
+      receipt.bundleError = String(result.stderr || result.stdout || 'bundle failed').trim().slice(0, 200);
+      for (const name of withCommits) targetNames.delete(name);
+    }
   }
 
-  for (const w of worktreeTargets) {
-    if (w.dirty > 0) {
-      const diff = runGit(['diff'], { cwd: w.path, check: false });
-      if (diff.status === 0 && diff.stdout.trim()) {
-        const patchPath = path.join(dir, `${path.basename(w.path)}.dirty.patch`);
-        fs.writeFileSync(patchPath, diff.stdout);
-        receipt.patches.push(patchPath);
-      }
+  const survivingWorktreeTargets = worktreeTargets.filter(
+    (w) => targetNames.has(w.branch) || (includeDetached && w.state === 'detached')
+  );
+  for (const w of survivingWorktreeTargets) {
+    // Salvage-then-remove, never keep-because-dirty: patches + untracked
+    // copies bank everything force-remove would destroy. The fresh-worktree
+    // grace was already applied when candidates were selected.
+    if (w.dirty > 0 && !salvageWorktree(w, dir, receipt)) {
+      // could not fully back up what force-remove would destroy — keep it
+      receipt.keptWorktrees.push(w.path);
+      if (w.branch) targetNames.delete(w.branch);
+      continue;
     }
     const removed = runGit(['worktree', 'remove', '--force', w.path], { cwd: root, check: false });
-    if (removed.status === 0) receipt.removedWorktrees.push(w.path);
+    if (removed.status === 0) {
+      receipt.removedWorktrees.push(w.path);
+    } 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
+      // unlock (or a dead lock can be challenged) instead of looping.
+      const reason = String(removed.stderr || removed.stdout || 'remove failed').trim().slice(0, 160);
+      receipt.keptWorktrees.push(`${w.path} (${reason})`);
+      if (w.branch) targetNames.delete(w.branch);
+    }
   }
 
   for (const name of targetNames) {
+    const entry = board.branches.find((b) => b.name === name);
+    // the board is a snapshot; an agent may have committed since it was
+    // taken. A branch that moved is left alone — the next reap sees the
+    // new truth and bundles it before touching it.
+    if (!entry || aheadCount(root, board.base, name) !== entry.ahead) {
+      receipt.keptMovedBranches.push(name);
+      continue;
+    }
     const deleted = runGit(['branch', '-D', name], { cwd: root, check: false });
     if (deleted.status === 0) receipt.deletedBranches.push(name);
   }
@@ -359,7 +456,11 @@ function printReceipt(receipt) {
   } else {
     console.log(`landing cleanup done — ${receipt.deletedBranches.length} pieces cleared, ${receipt.removedWorktrees.length} side copies removed`);
     if (receipt.bundle) console.log(`  backed up first, nothing lost: ${receipt.bundle}`);
+    if (receipt.bundleError) console.log(`  backup failed — unlanded work left in place: ${receipt.bundleError}`);
     for (const p of receipt.patches) console.log(`  unsaved edits saved: ${p}`);
+    for (const u of receipt.untracked || []) console.log(`  new files saved: ${u}`);
+    for (const k of receipt.keptWorktrees || []) console.log(`  ✋ kept, needs a human: ${k}`);
+    for (const m of receipt.keptMovedBranches || []) console.log(`  moved since scan, left alone: ${m}`);
     if (receipt.deletedRemote.length > 0) console.log(`  also cleared on github: ${receipt.deletedRemote.length}`);
   }
   console.log(`  still flying (recent work, left alone): ${receipt.kept.length}`);

package/commands/lesson.js

@@ -1,9 +1,112 @@
 const fs = require('fs');
 const path = require('path');
-const { writeLesson } = require('./autopilot');
+const {
+  writeLesson,
+  parseLessons,
+  loadLessonMetadata,
+  runLessonDetector,
+} = require('./autopilot');
 const { detectLessonContradictions } = require('../lib/lesson-contradiction');
 const taskDb = require('../lib/task-db');
 
+/**
+ * Tag a lesson's line in atris/lessons.md with `[resolved]` (idempotent).
+ * Inserts the marker right after the verdict separator so both the autopilot
+ * parser (`resolvedTag`) and the memory view treat the lesson as retired.
+ * @returns {boolean} true if the file was changed.
+ */
+function tagLessonResolvedInMd(cwd, slug) {
+  const lessonsPath = path.join(cwd, 'atris', 'lessons.md');
+  if (!fs.existsSync(lessonsPath)) return false;
+  const lines = fs.readFileSync(lessonsPath, 'utf8').split('\n');
+  let changed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/\*\*\[\d{4}-\d{2}-\d{2}\]\s+([\w-]+)\*\*/);
+    if (!m || m[1] !== slug) continue;
+    if (/\[resolved\]/i.test(lines[i])) continue; // already tagged
+    lines[i] = lines[i].replace(
+      /(\*\*\[\d{4}-\d{2}-\d{2}\]\s+[\w-]+\*\*\s*[—-]\s*(?:pass|fail)?\s*[—-]?\s*)/,
+      '$1[resolved] '
+    );
+    changed = true;
+  }
+  if (changed) fs.writeFileSync(lessonsPath, lines.join('\n'));
+  return changed;
+}
+
+/**
+ * Auto-resolve detector-backed fail lessons whose detector now passes.
+ *
+ * A `fail` lesson records a bug; its detector exits 0 once the bug is gone.
+ * When that happens we retire the lesson: stamp `status: resolved` +
+ * `resolved_at` in the atris/lessons.json sidecar and tag `[resolved]` in
+ * atris/lessons.md. Retired lessons stop being re-picked by the self-heal
+ * loop and drop out of the active memory view, keeping the lesson file small
+ * and trustworthy.
+ *
+ * Only detector-backed `fail` lessons self-retire. Prose-only lessons (no
+ * detector) and `observed` process rules are never auto-resolved — they have
+ * no falsifiable pass state.
+ *
+ * @param {string} cwd
+ * @param {object} [options] - { dryRun, detectorTimeout }
+ * @returns {{ checked: string[], resolved: string[], dryRun: boolean }}
+ */
+function autoResolveLessons(cwd, options = {}) {
+  const dryRun = !!options.dryRun;
+  const lessons = parseLessons(cwd);
+  const metadata = loadLessonMetadata(cwd);
+  const today = new Date().toISOString().slice(0, 10);
+  const checked = [];
+  const resolved = [];
+
+  for (const lesson of lessons) {
+    const meta = lesson.meta;
+    if (!meta || !meta.detector) continue;      // only detector-backed lessons self-retire
+    if (lesson.verdict !== 'fail') continue;     // only bug lessons carry a resolve semantic
+    if (meta.status === 'resolved') continue;    // already retired
+    if (meta.status === 'observed') continue;    // process rule, never auto-resolve
+    checked.push(lesson.id);
+    if (!runLessonDetector(meta.detector, cwd, options.detectorTimeout)) continue;
+    resolved.push(lesson.id);
+    if (!dryRun) {
+      metadata[lesson.id] = { ...meta, status: 'resolved', resolved_at: today };
+      tagLessonResolvedInMd(cwd, lesson.id);
+    }
+  }
+
+  if (!dryRun && resolved.length) {
+    const metaPath = path.join(cwd, 'atris', 'lessons.json');
+    fs.writeFileSync(metaPath, JSON.stringify(metadata, null, 2) + '\n');
+  }
+
+  return { checked, resolved, dryRun };
+}
+
+function resolveLessons(args) {
+  const cwd = process.cwd();
+  const json = args.includes('--json');
+  const dryRun = args.includes('--dry-run');
+  const { checked, resolved } = autoResolveLessons(cwd, { dryRun });
+
+  if (json) {
+    console.log(JSON.stringify({
+      ok: true,
+      action: 'lesson_resolve',
+      dry_run: dryRun,
+      detectors_checked: checked.length,
+      resolved_count: resolved.length,
+      resolved,
+    }, null, 2));
+    return;
+  }
+
+  const verb = dryRun ? 'would auto-resolve' : 'auto-resolved';
+  const tail = resolved.length ? `: ${resolved.join(', ')}` : '';
+  console.log(`ran ${checked.length} detector(s); ${verb} ${resolved.length} lesson(s)${tail}`);
+  if (dryRun) console.log('(dry-run: nothing written)');
+}
+
 function sweepLessons(args) {
   const cwd = process.cwd();
   const json = args.includes('--json');
@@ -127,11 +230,17 @@ function lessonAtris(subcommand, ...args) {
     return;
   }
 
+  if (subcommand === 'resolve') {
+    resolveLessons(args);
+    return;
+  }
+
   if (subcommand !== 'add') {
     console.log('');
     console.log('  Usage: atris lesson add <slug> <pass|fail> "<text>"');
     console.log('         atris lesson mine [--json] [--dry-run]');
     console.log('         atris lesson sweep [--json] [--dry-run]');
+    console.log('         atris lesson resolve [--json] [--dry-run]');
     console.log('');
     process.exit(subcommand ? 1 : 0);
   }
@@ -159,3 +268,5 @@ function lessonAtris(subcommand, ...args) {
 }
 
 module.exports = lessonAtris;
+module.exports.autoResolveLessons = autoResolveLessons;
+module.exports.tagLessonResolvedInMd = tagLessonResolvedInMd;

package/commands/linear.js

@@ -0,0 +1,38 @@
+const { createOfficialCliCommand } = require('../lib/official-cli-integration');
+
+const linearCommand = createOfficialCliCommand({
+  name: 'linear',
+  binary: 'linear',
+  versionArgs: ['--version'],
+  authArgs: ['auth', 'status'],
+  installHint: 'install the linear cli and ensure `linear` is on PATH',
+  loginHint: 'linear auth login',
+  commands: [
+    {
+      usage: 'issue list',
+      match: ['issue', 'list'],
+      forward: ['issue', 'list'],
+      description: 'list issues',
+    },
+    {
+      usage: 'issue create',
+      match: ['issue', 'create'],
+      forward: ['issue', 'create'],
+      description: 'create an issue',
+    },
+    {
+      usage: 'issue view',
+      match: ['issue', 'view'],
+      forward: ['issue', 'view'],
+      description: 'show issue details',
+    },
+    {
+      usage: 'issue update',
+      match: ['issue', 'update'],
+      forward: ['issue', 'update'],
+      description: 'update an issue',
+    },
+  ],
+});
+
+module.exports = { linearCommand };

package/commands/loops.js

@@ -0,0 +1,212 @@
+/**
+ * atris loops - one view of every background loop: what runs, what died,
+ * what you can start or stop.
+ *
+ *   atris loops              - the board (registry jobs, launchd agents, missions)
+ *   atris loops stop <id>    - disable a registry job or boot out a launchd agent
+ *   atris loops start <id>   - enable a registry job or kickstart a launchd agent
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+function heartbeatDir() {
+  return process.env.ATRIS_HEARTBEAT_DIR || path.join(os.homedir(), '.atris', 'heartbeat');
+}
+
+function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function registryPath() {
+  return path.join(heartbeatDir(), 'registry.json');
+}
+
+function loadRegistry() {
+  const registry = readJson(registryPath(), null);
+  return registry && Array.isArray(registry.jobs) ? registry : { jobs: [] };
+}
+
+function loadRunState() {
+  return readJson(path.join(heartbeatDir(), 'state.json'), {});
+}
+
+function agoText(iso) {
+  const then = Date.parse(iso || '');
+  if (!Number.isFinite(then)) return 'never';
+  const mins = Math.max(0, Math.round((Date.now() - then) / 60000));
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 48) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+
+function listLaunchdAgents() {
+  let raw = '';
+  try {
+    raw = execSync('launchctl list', { encoding: 'utf8', timeout: 10000 });
+  } catch {
+    return [];
+  }
+  return raw
+    .split('\n')
+    .filter(line => line.includes('com.atris.'))
+    .map(line => {
+      const [pid, exitCode, label] = line.trim().split(/\s+/);
+      return {
+        label,
+        running: pid !== '-',
+        pid: pid !== '-' ? pid : null,
+        lastExit: exitCode,
+      };
+    })
+    .filter(agent => agent.label);
+}
+
+function workspaceMission(cwd) {
+  const goalState = readJson(path.join(cwd, '.atris', 'state', 'atris_goal.json'), null);
+  const goal = goalState && goalState.goal;
+  if (!goal || !goal.objective) return null;
+  const started = Date.parse(goal.created_at || '');
+  const elapsedMins = Number.isFinite(started) ? Math.round((Date.now() - started) / 60000) : null;
+  return {
+    id: goal.mission_id || '?',
+    status: goal.mission_status || '?',
+    objective: String(goal.objective),
+    elapsedMins,
+  };
+}
+
+function showBoard(cwd) {
+  const registry = loadRegistry();
+  const state = loadRunState();
+
+  console.log('background loops');
+  console.log('');
+
+  const enabled = registry.jobs.filter(job => job.enabled !== false && job.disabled !== true);
+  const disabledCount = registry.jobs.length - enabled.length;
+  console.log(`heartbeat registry (${enabled.length} live, ${disabledCount} retired)`);
+  if (!enabled.length) {
+    console.log('  none declared');
+  }
+  for (const job of enabled) {
+    const run = state[job.id] || {};
+    const fails = Number(run.consecutive_fails || 0);
+    const health = fails > 2 ? `${fails} consecutive fails` : fails > 0 ? `${fails} recent fail${fails === 1 ? '' : 's'}` : 'healthy';
+    const cadence = job.cadence_minutes >= 60 ? `${Math.round(job.cadence_minutes / 60)}h` : `${job.cadence_minutes}m`;
+    console.log(`  ${String(job.id).padEnd(22)} every ${String(cadence).padEnd(5)} last ${agoText(run.last_run).padEnd(9)} ${health}`);
+    console.log(`  ${''.padEnd(22)} ${String(job.purpose || '').slice(0, 84)}`);
+  }
+  console.log('');
+
+  const agents = listLaunchdAgents();
+  console.log(`launchd agents (${agents.length})`);
+  for (const agent of agents) {
+    const status = agent.running ? `running pid ${agent.pid}` : `loaded, last exit ${agent.lastExit}`;
+    console.log(`  ${agent.label.padEnd(44)} ${status}`);
+  }
+  if (!agents.length) console.log('  none');
+  console.log('');
+
+  const mission = workspaceMission(cwd);
+  console.log('mission (this workspace)');
+  if (mission) {
+    const elapsed = mission.elapsedMins === null ? '' : ` · ${mission.elapsedMins}m in`;
+    console.log(`  ${mission.id}`);
+    console.log(`  ${mission.status}${elapsed} · ${mission.objective.slice(0, 80)}`);
+  } else {
+    console.log('  none active');
+  }
+  console.log('');
+  console.log('control: atris loops stop <id> · atris loops start <id>');
+  console.log('ids: registry job id, or a com.atris.* launchd label');
+}
+
+function saveRegistry(registry) {
+  const target = registryPath();
+  fs.copyFileSync(target, `${target}.bak`);
+  fs.writeFileSync(target, `${JSON.stringify(registry, null, 2)}\n`);
+}
+
+function setRegistryJob(id, enabled) {
+  const registry = loadRegistry();
+  const job = registry.jobs.find(row => row.id === id);
+  if (!job) return false;
+  job.enabled = enabled;
+  if (enabled) {
+    delete job.disabled;
+    delete job.disabled_reason;
+  } else {
+    job.disabled = true;
+    job.disabled_reason = `stopped via atris loops ${new Date().toISOString().slice(0, 10)}`;
+  }
+  saveRegistry(registry);
+  return true;
+}
+
+function launchdControl(label, action) {
+  const uid = process.getuid();
+  if (action === 'stop') {
+    const result = spawnSync('launchctl', ['bootout', `gui/${uid}/${label}`], { encoding: 'utf8' });
+    return result.status === 0;
+  }
+  const plist = path.join(os.homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+  if (!fs.existsSync(plist)) return false;
+  const bootstrap = spawnSync('launchctl', ['bootstrap', `gui/${uid}`, plist], { encoding: 'utf8' });
+  if (bootstrap.status === 0) return true;
+  const kick = spawnSync('launchctl', ['kickstart', '-k', `gui/${uid}/${label}`], { encoding: 'utf8' });
+  return kick.status === 0;
+}
+
+function controlLoop(id, action) {
+  const target = String(id || '').trim();
+  if (!target) {
+    console.error(`Usage: atris loops ${action} <id>`);
+    process.exit(1);
+  }
+  if (target.startsWith('com.atris.')) {
+    const ok = launchdControl(target, action);
+    if (!ok) {
+      console.error(`Could not ${action} ${target}. Check: launchctl print gui/$(id -u)/${target}`);
+      process.exit(1);
+    }
+    console.log(`${action === 'stop' ? 'Stopped' : 'Started'} ${target}.`);
+    return;
+  }
+  const ok = setRegistryJob(target, action === 'start');
+  if (!ok) {
+    console.error(`No registry job named "${target}". Run: atris loops`);
+    process.exit(1);
+  }
+  console.log(`${action === 'stop' ? 'Disabled' : 'Enabled'} ${target} in the heartbeat registry (backup written).`);
+}
+
+function loopsCommand(subcommand, ...args) {
+  switch (subcommand) {
+    case undefined:
+    case 'board':
+    case 'list':
+      showBoard(process.cwd());
+      break;
+    case 'stop':
+      controlLoop(args[0], 'stop');
+      break;
+    case 'start':
+      controlLoop(args[0], 'start');
+      break;
+    default:
+      console.log('Loop commands:');
+      console.log('  atris loops              - board: registry jobs, launchd agents, mission');
+      console.log('  atris loops stop <id>    - disable a registry job or stop a launchd agent');
+      console.log('  atris loops start <id>   - enable a registry job or start a launchd agent');
+  }
+}
+
+module.exports = { loopsCommand, showBoard };