atris 3.82.1 → 3.82.3

package/README.md

@@ -18,7 +18,7 @@ A computer can be personal or shared by a business. It can run a job like code,
 
 Atris gives Claude Code, Codex, Cursor and any other agent a memory that lasts across sessions. The memory is plain files in your repo: `atris/MAP.md` (where everything lives, with file and line numbers), `atris/wiki/` (what the team learned, as pages linked with `[[page-name]]`), `atris/logs/` (what was done and checked each day), and `atris task` (open work, who claimed it, and the proof). Every agent reads the same files before it acts, so several agents and people share one memory, reviewed in git like code.
 
-Mem0, Zep and Letta remember the users of a chat app. Atris remembers the project. Guide and comparison: https://atris.ai/blog/memory-for-coding-agents
+Mem0, Zep and Letta remember the users of a chat app. Atris remembers the project. Patterns and setup: [docs/agent-memory.md](docs/agent-memory.md). Comparison: https://atris.ai/blog/memory-for-coding-agents
 
 ## Check what ChatGPT can read about your business
 

package/commands/mission.js

@@ -7,7 +7,7 @@ const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
-const { memberProcessPrompt } = require('../lib/member-context');
+const { memberProcessPrompt, currentWorkPrompt } = require('../lib/member-context');
 const { memberIdentityLine, missionObjectiveLine } = require('../lib/member-identity');
 const { formatToolStep, formatCodexEvent, appendProgress, reportProgress, startedLine, newRunToken, runMarker } = require('../lib/member-progress');
 const {
@@ -8147,6 +8147,8 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
     ...turnDownLines,
     ...(sharedProcess ? ['', sharedProcess] : []),
     ...preloadedContextLines,
+    '',
+    currentWorkPrompt(cwd, { ...mission, verifier: frozen.verifier }),
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,

package/commands/security-review.js

@@ -123,10 +123,10 @@ function applyBaselineOptions(root, rawFindings, opts) {
 
 function securityReviewCommand(argv = []) {
   const sub = argv[0];
+  if (sub === 'audit') return auditCommand(argv.slice(1));
   if (sub === 'help' || argv.includes('-h') || argv.includes('--help')) return printHelp();
   if (sub === 'rules') return printRules();
   if (sub === 'hook' || sub === 'install-hook') return installHook();
-  if (sub === 'audit') return auditCommand(argv.slice(1));
 
   const root = process.cwd();
   let opts;
@@ -402,7 +402,7 @@ function installHook() {
 }
 
 function parseAuditArgs(argv) {
-  const opts = { profile: 'standard', scope: [], json: false, planOnly: false, budget: null, out: null, hunter: null, verifier: null, timeoutMs: null };
+  const opts = { profile: 'standard', scope: [], json: false, planOnly: false, budget: null, out: null, hunter: null, verifier: null, timeoutMs: null, engine: null, yes: false, upload: true, scheduled: false };
   const takes = (i, flag) => {
     if (!argv[i + 1] || argv[i + 1].startsWith('--')) throw new Error(`${flag} needs a value`);
     return argv[i + 1];
@@ -420,6 +420,10 @@ function parseAuditArgs(argv) {
     else if (flag === '--hunter') opts.hunter = value();
     else if (flag === '--verifier') opts.verifier = value();
     else if (flag === '--timeout') opts.timeoutMs = Number(value()) * 1000;
+    else if (flag === '--engine') opts.engine = value();
+    else if (flag === '--yes' || flag === '-y') opts.yes = true;
+    else if (flag === '--no-upload') opts.upload = false;
+    else if (flag === '--scheduled') opts.scheduled = true;
     else if (arg.startsWith('-')) throw new Error(`unknown flag: ${arg}`);
     else opts.scope.push(arg);
   }
@@ -427,6 +431,7 @@ function parseAuditArgs(argv) {
   if (!PROFILES.includes(opts.profile)) throw new Error(`--profile must be one of ${PROFILES.join(', ')}`);
   if (opts.budget !== null && (!Number.isInteger(opts.budget) || opts.budget < 1 || opts.budget > 500)) throw new Error('--budget must be a whole number from 1 to 500');
   if (opts.timeoutMs !== null && (!Number.isFinite(opts.timeoutMs) || opts.timeoutMs < 10000)) throw new Error('--timeout is in seconds, at least 10');
+  if (opts.engine !== null && !['atris', 'local'].includes(opts.engine)) throw new Error('--engine must be atris or local');
   return opts;
 }
 
@@ -454,7 +459,7 @@ function renderAuditLanding({ dir, meta, records }) {
   } else {
     L.push(`  ${confirmed.length} confirmed${sevText ? ` (${sevText})` : ''} · ${needs.length} need a fact from you · ${rejected.length} disproved`);
     L.push(`  read ${cov.fresh} areas this run, ${cov.carried} carried unchanged, ${cov.deferred || 0} left for the next run`);
-    L.push(`  found by ${meta.engines.hunter}, checked by ${meta.engines.verifier}${meta.engines.hunter === meta.engines.verifier ? ' (same engine)' : ''} · ${meta.invocations.used} engine calls of ${meta.budget}`);
+    L.push(`  found by ${meta.engines.hunter}, checked by ${meta.engines.verifier}${meta.engines.hunter === meta.engines.verifier ? ' (same engine)' : ''} · ${meta.invocations.used} engine calls of ${meta.budget}${meta.credits_used ? ` · ${meta.credits_used} credits used` : ''}`);
     for (const r of confirmed.slice(0, 6)) {
       const sink = r.trace[r.trace.length - 1];
       L.push(`    ${r.severity.overall.padEnd(8)} ${r.title} (${sink.file}:${sink.line})`);
@@ -465,33 +470,204 @@ function renderAuditLanding({ dir, meta, records }) {
   return L.join('\n');
 }
 
-async function auditCommand(argv) {
+// Ask once on a terminal. Anything but y or yes is a no.
+function askYesNo(question, { input = process.stdin, output = process.stdout } = {}) {
+  return new Promise((resolve) => {
+    const rl = require('readline').createInterface({ input, output });
+    rl.question(question, (answer) => { rl.close(); resolve(/^\s*y(es)?\s*$/i.test(String(answer || ''))); });
+  });
+}
+
+async function uploadAfterRun(dir, { token, quiet, cloud }) {
+  const res = await cloud.uploadRun(dir, { token });
+  const say = quiet ? (m) => console.error(m) : (m) => console.log(m);
+  if (res.ok) say('  saved the summary to your atris account (no source code was sent)');
+  else say(`  warning: could not save the summary to your atris account: ${res.reason}. the review itself is done`);
+  return res;
+}
+
+async function auditUploadCommand(argv, deps) {
+  const audit = require('../lib/security-audit');
+  const cloud = deps.cloud || require('../lib/sentinel-cloud');
+  const token = deps.token !== undefined ? deps.token : cloud.authToken();
+  if (!token) { console.error('  log in first with atris login. then run atris sentinel upload again'); return 2; }
+  const arg = argv.find((a) => !a.startsWith('-'));
+  let dir = arg ? path.resolve(arg) : null;
+  if (!dir) {
+    const last = audit.latestRun(deps.root || process.cwd());
+    if (!last) { console.error('  no sentinel review has run for this repo yet'); return 2; }
+    dir = last.dir;
+  }
+  if (!fs.existsSync(path.join(dir, 'run-metadata.json'))) { console.error(`  ${tildePath(dir)} is not a sentinel run folder`); return 2; }
+  const res = await cloud.uploadRun(dir, { token });
+  if (!res.ok) { console.error(`  could not save ${path.basename(dir)}: ${res.reason}`); return 1; }
+  console.log(`  saved ${path.basename(dir)} to your atris account (no source code was sent)`);
+  return 0;
+}
+
+// Price one quick run on atris models for a folder without calling any
+// model: the audit plans, the estimate is quoted, and the plan is dropped.
+async function quoteQuickRun(target, { hunter, verifier, token, cloud }) {
+  const audit = require('../lib/security-audit');
+  let estimate = null;
+  await audit.runAudit({
+    root: target, profile: 'quick', hunter, verifier,
+    runJobs: async () => { throw new Error('no model call while pricing a schedule'); },
+    confirmSpend: async (est) => { estimate = est; return false; },
+  });
+  if (!estimate) throw new Error('could not plan a review for this folder');
+  return cloud.quoteEstimate(estimate, { token });
+}
+
+async function auditScheduleCommand(argv, deps) {
+  const cloud = deps.cloud || require('../lib/sentinel-cloud');
+  const { installKeep, removeKeep } = require('../lib/campaign-keep');
+  const uninstall = argv.includes('--uninstall');
+  let every = 'day';
+  let target = null;
+  let engine = null;
+  let maxCredits = null;
+  let yes = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const [flag, inline] = a.startsWith('--') && a.includes('=') ? [a.slice(0, a.indexOf('=')), a.slice(a.indexOf('=') + 1)] : [a, null];
+    const value = () => (inline !== null ? inline : argv[++i]);
+    if (flag === '--every') every = value();
+    else if (flag === '--engine') engine = value();
+    else if (flag === '--max-credits') maxCredits = Number(value());
+    else if (flag === '--yes' || flag === '-y') yes = true;
+    else if (flag === '--uninstall' || flag === '--install') continue;
+    else if (a.startsWith('-')) { console.error(`  unknown flag: ${a}`); return 2; }
+    else target = a;
+  }
+  if (!cloud.SCHEDULE_EVERY[every]) { console.error('  use --every day or --every week'); return 2; }
+  if (engine !== null && engine !== 'atris' && engine !== 'local') { console.error('  --engine must be atris or local'); return 2; }
+  if (maxCredits !== null && (!Number.isInteger(maxCredits) || maxCredits < 1)) { console.error('  --max-credits must be a whole number of credits, at least 1'); return 2; }
+  target = path.resolve(target || deps.root || process.cwd());
+  if (!fs.existsSync(target) || !fs.statSync(target).isDirectory()) { console.error(`  ${target} is not a folder`); return 2; }
+  const atrisBin = deps.atrisBin || path.resolve(__dirname, '..', 'bin', 'atris.js');
+  const plan = cloud.schedulePlan({ target, every, homeDir: deps.homeDir, platform: deps.platform, atrisBin, envPath: deps.envPath });
+  const keepDeps = deps.spawn ? { spawn: deps.spawn } : {};
+  if (uninstall) {
+    // Same folder makes the same timer name, so --every does not matter here.
+    const removed = removeKeep(plan, keepDeps);
+    if (!removed.ok) { console.error(`  could not remove the timer: ${removed.error}`); return 1; }
+    cloud.removeApproval(target, deps.homeDir);
+    console.log(`  scheduled reviews ${removed.removed === false ? 'were not on' : 'are off'} for ${tildePath(target)}`);
+    return 0;
+  }
+  const space = require('../lib/worktree-space');
+  if (!deps.atrisBin && (space.isAgentCopyPath(atrisBin) || space.isScratchPath(atrisBin))) {
+    console.error(`  refusing: this atris runs from ${path.dirname(path.dirname(atrisBin))}, a folder that gets removed. install the timer from a lasting atris install`);
+    return 2;
+  }
+
+  // The engine is decided now, with the owner here, and written down. A
+  // scheduled run never picks again.
+  const token = deps.token !== undefined ? deps.token : cloud.authToken();
+  let engines;
+  try { engines = cloud.resolveEngines({ engine, token, env: deps.env || process.env }); } catch (e) { console.error(`  ${e.message}`); return 2; }
+  let approval;
+  if (engines.mode === 'atris') {
+    let quote;
+    try { quote = await quoteQuickRun(target, { hunter: engines.hunter, verifier: engines.verifier, token, cloud }); } catch (e) { console.error(`  no timer was set. ${e.message}`); return 2; }
+    const cap = maxCredits || quote.credits;
+    console.log(`\n  each scheduled review runs on atris models (no codex or claude needed)`);
+    console.log(`  ${cloud.describeQuote(quote)}`);
+    console.log(`  each run may spend at most ${cap} credits, once a ${every}. a run that reaches that stops\n`);
+    if (!yes) {
+      const input = deps.input || process.stdin;
+      if (!input.isTTY && !deps.input) { console.error('  no timer was set. add --yes to approve this spend without the question'); return 1; }
+      const ok = await (deps.ask || askYesNo)(`  approve up to ${cap} credits per scheduled run? (y/N) `, { input, output: process.stdout });
+      if (!ok) { console.log('  no timer was set'); return 1; }
+    }
+    approval = { engine: 'atris', hunter: engines.hunter, verifier: engines.verifier, max_credits: cap, quoted_credits: quote.credits, every, approved_at: new Date().toISOString() };
+  } else {
+    approval = { engine: 'local', every, approved_at: new Date().toISOString() };
+  }
+  cloud.writeApproval(target, approval, deps.homeDir);
+  const installed = installKeep(plan, keepDeps);
+  if (!installed.ok) { cloud.removeApproval(target, deps.homeDir); console.error(`  could not install the timer: ${installed.error}`); return 1; }
+  console.log(`  scheduled reviews are on for ${tildePath(target)}, once a ${every}`);
+  console.log('  each run uses the quick profile and saves its summary to your atris account');
+  if (approval.engine === 'local') console.log('  runs use only codex and claude on this machine. they never switch to atris models');
+  else console.log(`  runs use atris models and stop at ${approval.max_credits} credits`);
+  console.log(`  log: ${tildePath(plan.log_path)}`);
+  console.log(`  stop with: atris sentinel schedule --uninstall ${tildePath(target)}`);
+  return 0;
+}
+
+async function auditCommand(argv, deps = {}) {
   if (argv[0] === 'help' || argv.includes('-h') || argv.includes('--help')) return printAuditHelp();
   const audit = require('../lib/security-audit');
+  const root = deps.root || process.cwd();
   if (argv[0] === 'status' || argv[0] === 'last') {
-    const last = audit.latestRun(process.cwd());
+    const last = audit.latestRun(root);
     if (!last || !last.meta) { console.log('\n  no sentinel audit has run for this repo yet\n'); return 0; }
     if (argv.includes('--json')) { console.log(JSON.stringify({ dir: last.dir, meta: last.meta, findings: last.records }, null, 2)); return 0; }
     console.log(renderAuditLanding({ dir: last.dir, meta: last.meta, records: last.records }));
     return 0;
   }
+  if (argv[0] === 'upload') return auditUploadCommand(argv.slice(1), deps);
+  if (argv[0] === 'schedule') return auditScheduleCommand(argv.slice(1), deps);
   let opts;
   try { opts = parseAuditArgs(argv); } catch (e) { console.error(`security-review audit: ${e.message}`); return 2; }
+  const cloud = deps.cloud || require('../lib/sentinel-cloud');
+  // A timer run does only what the owner approved at install.
+  let capOverride = null;
+  if (opts.scheduled) {
+    const approval = cloud.readApproval(root, deps.homeDir);
+    if (!approval) { console.error('security-review audit: this folder has no approved schedule. nothing ran. run atris sentinel schedule again'); return 2; }
+    opts.hunter = null;
+    opts.verifier = null;
+    opts.engine = approval.engine;
+    if (approval.engine === 'atris') { opts.yes = true; capOverride = Number(approval.max_credits); }
+  }
+  const token = deps.token !== undefined ? deps.token : cloud.authToken();
+  let engines;
+  try { engines = cloud.resolveEngines({ engine: opts.engine, hunter: opts.hunter, verifier: opts.verifier, token, env: deps.env || process.env }); } catch (e) { console.error(`security-review audit: ${e.message}`); return 2; }
+  const hunter = engines.hunter || undefined;
+  const verifier = engines.verifier || undefined;
+  const hosted = audit.isHostedEngine(hunter) || audit.isHostedEngine(verifier);
+  if (hosted && !token) { console.error('security-review audit: reviews on atris models need a login; run atris login first'); return 2; }
   const log = opts.json ? () => {} : (msg) => console.log(`  · ${msg}`);
+  const tell = opts.json ? (m) => console.error(m) : (m) => console.log(m);
+  if (hosted && engines.chosen === 'no_local_engine' && !opts.planOnly) tell('  no codex or claude found on this machine. this review runs on atris models');
+  let runJobs = deps.runJobs;
+  const spend = hosted ? cloud.spendGuard({ quoteCall: deps.quoteCall }) : null;
+  if (!runJobs && hosted) runJobs = cloud.atrisJobRunner({ token, spend });
+  const confirmSpend = async (estimate) => {
+    const quote = await cloud.quoteEstimate(estimate, { token });
+    spend.max = capOverride || quote.credits;
+    spend.limits = quote.limits;
+    tell(`\n  ${cloud.describeQuote(quote)}\n`);
+    if (capOverride) tell(`  this scheduled run may spend at most ${capOverride} credits, as approved`);
+    if (opts.yes) return true;
+    const input = deps.input || process.stdin;
+    if (!input.isTTY && !deps.input) { console.error('  nothing was spent. add --yes to run without this question'); return false; }
+    const yes = await (deps.ask || askYesNo)('  spend these credits? (y/N) ', { input, output: opts.json ? process.stderr : process.stdout });
+    if (!yes) tell('  nothing was spent');
+    return yes;
+  };
   let result;
   try {
     result = await audit.runAudit({
-      root: process.cwd(), profile: opts.profile, scope: opts.scope, budget: opts.budget ?? undefined, out: opts.out,
-      hunter: opts.hunter || undefined, verifier: opts.verifier || undefined, planOnly: opts.planOnly,
+      root, profile: opts.profile, scope: opts.scope, budget: opts.budget ?? undefined, out: opts.out,
+      hunter, verifier, planOnly: opts.planOnly, runJobs, confirmSpend,
       timeoutMs: opts.timeoutMs || undefined, log,
     });
   } catch (e) {
     console.error(`security-review audit: ${e.message}`);
     return 2;
   }
+  if (result.declined) return 1;
   const fail = audit.shouldFailAudit(result.records);
   if (opts.json) console.log(JSON.stringify({ ok: !fail, dir: result.dir, meta: result.meta, findings: result.records }, null, 2));
   else console.log(renderAuditLanding(result));
+  if (spend && spend.blocked) tell(`  stopped at the approved limit of ${spend.max} credits. ${spend.blocked} model call${spend.blocked === 1 ? '' : 's'} did not run and wait for the next run`);
+  if (opts.upload && token && !opts.planOnly) {
+    try { await uploadAfterRun(result.dir, { token, quiet: opts.json, cloud }); } catch (e) { tell(`  warning: could not save the summary to your atris account: ${e.message}. the review itself is done`); }
+  }
   return fail ? 1 : 0;
 }
 
@@ -510,6 +686,37 @@ function printAuditHelp() {
     atris security-review audit --out DIR       write the run here (outside the repo)
     atris security-review audit status          the last run's landing
 
+  on atris models (no other AI subscription needed, paid in atris credits):
+
+    atris sentinel --engine atris               atris:fast searches, atris:pro checks
+    atris sentinel --engine atris --yes         skip the price question
+    atris sentinel --engine local               only codex and claude on this machine
+
+  with no --engine, local engines run when codex or claude is installed.
+  atris models run only when neither is installed and you are logged in.
+  every run on atris models shows the most it can cost first and stops
+  before it could pass that. lines that look like secrets are hidden and
+  only tracked files inside the review are ever sent.
+
+  saving results to your atris account (on when you are logged in):
+
+    atris sentinel --no-upload                  keep this run on this machine only
+    atris sentinel upload [run-folder]          save a past run (default: the last one)
+
+  only the summary is saved: plain sentences, file:line locations and counts.
+  source code and code lines never leave in an upload.
+
+  reviews on a timer:
+
+    atris sentinel schedule --every day [path]  quick review once a day, saved to your account
+    atris sentinel schedule --every week [path] once a week
+    atris sentinel schedule --engine atris --max-credits 20
+                                                timed runs on atris models, at most 20 credits each
+    atris sentinel schedule --uninstall [path]  stop the timer
+
+  the engine is picked when the timer goes on. on atris models you see the
+  price and say yes then. a timed run never switches to atris models later.
+
   How it works: every source file x attack class with a reason to be read
   becomes an area in a coverage ledger. Read-only engine hunters each own a
   few areas. A coverage critic names gaps. Every candidate goes to a different
@@ -553,4 +760,4 @@ function printHelp() {
   return 0;
 }
 
-module.exports = { securityReviewCommand };
+module.exports = { securityReviewCommand, auditCommand };

package/commands/task.js

@@ -10,6 +10,7 @@ const { execSync } = require('node:child_process');
 const path = require('path');
 const os = require('os');
 const { hasFlag } = require('../lib/arg-parser');
+const { buildNextWorkContext, reconcileTaskRows } = require('../lib/next-work-context');
 const { argsWantHelp } = require('../lib/noninteractive');
 const {
   compactErrorPayload,
@@ -74,6 +75,7 @@ const {
 } = require('../lib/task-decision');
 const {
   buildFirstMinute,
+  loadLocalTaskState,
   deskNextCommand,
   firstTalkCommand,
   folderName,
@@ -5880,27 +5882,11 @@ function cmdNextTruth(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const workspaceRoot = taskDb.workspaceRoot();
-  const rows = taskDb.listTasks(db, { workspaceRoot, limit: 500 });
-  const existingProj = readProjectionFile(workspaceRoot);
-  const dbHasActionable = rows.some((task) => {
-    const status = task && task.status;
-    return status === 'open' || status === 'claimed' || status === 'review';
-  });
-  const projHasActionable = Boolean(
-    existingProj
-    && Array.isArray(existingProj.tasks)
-    && existingProj.tasks.some((task) => {
-      const status = task && task.status;
-      return status === 'open' || status === 'claimed' || status === 'review';
-    }),
-  );
+  const snapshot = loadLocalTaskState(workspaceRoot);
   let projection;
   let outPath;
-  if (!dbHasActionable && projHasActionable) {
-    projection = existingProj;
-    outPath = path.resolve(path.join(workspaceRoot || '.', '.atris', 'state', 'tasks.projection.json'));
-  } else if (rows.length === 0 && existingProj && Array.isArray(existingProj.tasks) && existingProj.tasks.length > 0) {
-    projection = existingProj;
+  if (snapshot.source !== 'database') {
+    projection = { tasks: snapshot.tasks };
     outPath = path.resolve(path.join(workspaceRoot || '.', '.atris', 'state', 'tasks.projection.json'));
   } else {
     const written = writeDefaultProjection(taskDb, db);
@@ -5928,6 +5914,7 @@ function cmdNextTruth(args) {
       scope: normalizeTaskQueueScope(scope),
       projection_path: outPath,
       task: task ? compactTaskFromProjection(projection, task.id) : null,
+      context: buildNextWorkContext({ root: workspaceRoot, tasks: reconcileTaskRows(snapshot.tasks, projection.tasks || []), selected: task, owner: String(owner), taskSource: snapshot.source, generatedAt: snapshot.generated_at }),
     });
     return;
   }

package/commands/worktree.js

@@ -12,10 +12,12 @@ const worktreeCore = require('../lib/worktree-core');
 
 const {
   ATRIS_BIN,
+  RESCUE_IDLE_MS,
+  finishShippedCopy,
+  formatKib,
   SWEEP_IDLE_MS,
   SWEEP_EVERY_HOURS,
   SWEEP_KEPT_LABELS,
-  announceShippedCopyRemoval,
   assertOneLapProofTree,
   baseBranchName,
   branchName,
@@ -50,6 +52,7 @@ const {
   prMergeRef,
   protectedPushRefusal,
   readOneLapProofBinding,
+  reapPushedCopy,
   reapShippedCopy,
   recordWorktreeRemoval,
   refreshMovedMapRefs,
@@ -190,6 +193,7 @@ function shipHelp() {
   console.log('  protected-lane tasks (billing, money, deploy, feedback, ...) can be pushed for review without --merge;');
   console.log('  landing one with --merge or --local needs --allow-denied-lane on written order');
   console.log('  --no-map-refresh  skip the automatic refresh of moved map line references');
+  console.log('  --keep-copy     keep this build copy; by default it is removed once the work lands or is pushed');
   console.log('  unstaged regenerated adapter files are skipped unless staged first or named in --message');
   console.log('  recommended flight verify: npm run test:fast && node --test <focused files>');
 }
@@ -204,6 +208,7 @@ function shipWorktree(args) {
   const noPr = hasFlag(args, '--no-pr');
   const localMode = hasFlag(args, '--local') || hasFlag(args, '--local-merge');
   const merge = hasFlag(args, '--merge');
+  const keepCopy = hasFlag(args, '--keep-copy');
   const message = readFlag(args, '--message') || readFlag(args, '-m');
   const verify = readFlag(args, '--verify');
   let branch = currentBranch(root);
@@ -351,7 +356,7 @@ function shipWorktree(args) {
     }
     console.log('pr: skipped (local mode)');
     if (merge && !dryRun) runShipHealthCheck(primary || root);
-    if (landedOn) announceShippedCopyRemoval(scheduleShippedCopyRemoval({ root, primary, branch, base: landedOn }));
+    if (landedOn) finishShippedCopy({ root, primary, branch, landedOn, keep: keepCopy });
     console.log('done: worktree shipped');
     return 0;
   }
@@ -385,6 +390,7 @@ function shipWorktree(args) {
         }
         if (state.state === 'OPEN' && !state.mergedAt) {
           console.log('merge: pending; kept the source branch while required checks finish');
+          finishShippedCopy({ root, primary, branch, keep: keepCopy });
           return 0;
         }
         if (state.state !== 'MERGED' || !state.mergedAt) {
@@ -414,7 +420,7 @@ function shipWorktree(args) {
     }, { worktree: root });
   } catch {}
   if (merge && !dryRun) runShipHealthCheck(primary || root);
-  if (landedOn) announceShippedCopyRemoval(scheduleShippedCopyRemoval({ root, primary, branch, base: landedOn }));
+  if (!dryRun) finishShippedCopy({ root, primary, branch, landedOn, keep: keepCopy });
   console.log('done: worktree shipped');
   return 0;
 }
@@ -425,7 +431,10 @@ function reapShipped() {
     console.error('reap-shipped: ATRIS_REAP_WORKTREE is not set');
     return 2;
   }
-  const result = reapShippedCopy({ root: process.cwd(), target, base: process.env.ATRIS_REAP_BASE || '' });
+  const base = process.env.ATRIS_REAP_BASE || '';
+  const result = base
+    ? reapShippedCopy({ root: process.cwd(), target, base })
+    : reapPushedCopy({ primary: process.cwd(), target, branch: process.env.ATRIS_REAP_BRANCH || '' });
   console.log(`reap-shipped: ${result.removed ? 'removed' : 'kept'} ${target} (${result.reason})`);
   return result.removed ? 0 : 1;
 }
@@ -495,8 +504,14 @@ function sweep(args) {
     console.error('Usage: atris worktree sweep [--apply] [--json] [--workspace <dir>] [--idle-hours <n>]');
     return 2;
   }
+  const rescueDays = Number(readFlag(args, '--rescue-after-days', process.env.ATRIS_WORKTREE_RESCUE_DAYS || String(RESCUE_IDLE_MS / 86400000)));
+  if (!Number.isFinite(rescueDays) || rescueDays <= 0) {
+    console.error('Usage: atris worktree sweep [--apply] [--json] [--workspace <dir>] [--idle-hours <n>] [--rescue] [--rescue-after-days <n>]');
+    return 2;
+  }
   const apply = hasFlag(args, '--apply');
-  const report = sweepWorkspace({ workspace, apply, idleMs: idleHours * 3600000 });
+  const rescue = hasFlag(args, '--rescue');
+  const report = sweepWorkspace({ workspace, apply, rescue, idleMs: idleHours * 3600000, rescueIdleMs: rescueDays * 86400000 });
   if (hasFlag(args, '--json')) {
     console.log(JSON.stringify({ ok: !report.error, ...report }, null, 2));
     return report.error ? 1 : 0;
@@ -514,9 +529,11 @@ function sweep(args) {
       console.log(`${repo.name}: skipped (${repo.error || repo.skipped})`);
       continue;
     }
-    const gone = apply ? repo.removed : repo.candidates;
+    const saved = apply ? repo.rescued : repo.rescueCandidates;
+    const savedSet = new Set(saved);
+    const gone = (apply ? repo.removed : repo.candidates).filter((item) => !savedSet.has(item));
     const cleared = apply ? repo.cachePruned : repo.cacheCandidates.filter((item) => item.reason === 'generated_webpack_cache');
-    removedTotal += gone.length;
+    removedTotal += gone.length + saved.length;
     clearedTotal += cleared.length;
     reviewTotal += repo.cacheCandidates.filter((item) => item.reason === 'manual_review_required').length;
     const counts = {};
@@ -526,7 +543,18 @@ function sweep(args) {
     }
     const keptText = Object.entries(counts).map(([label, count]) => `${count} ${label}`).join(', ');
     console.log(`${repo.name}: ${apply ? 'removed' : 'would remove'} ${plural(gone.length, 'finished copy', 'finished copies')}, ${apply ? 'cleared' : 'would clear'} ${plural(cleared.length, 'webpack cache', 'webpack caches')}; kept ${repo.kept.length}${keptText ? ` (${keptText})` : ''}`);
+    if (saved.length) console.log(`  ${apply ? 'saved and removed' : 'would save and remove'} ${plural(saved.length, 'abandoned copy', 'abandoned copies')}`);
+    for (const item of saved) {
+      const what = item.reason === 'pushed_branch' ? 'already on origin' : `${plural(item.changed_files || 0, 'changed file', 'changed files')}, idle ${item.idle_days} days`;
+      console.log(`  ${apply ? 'saved' : 'save'}: ${item.path} -> origin/${item.rescue_branch} (${what}, ${formatKib(item.size_kib)})`);
+    }
     for (const item of gone) console.log(`  ${apply ? 'removed' : 'remove'}: ${item.path}`);
+    for (const item of repo.kept) {
+      if (item.reason === 'rescue_push_failed') console.log(`  kept: ${item.path} (could not push its work to origin/${item.rescue_branch}: ${item.error})`);
+      if (item.reason === 'unprovable') console.log(`  kept: ${item.path} (${item.why})`);
+      if (item.reason === 'stale_dirty' || item.reason === 'stale_unpushed') console.log(`  stale: ${item.path} (idle ${item.idle_days} days; atris worktree sweep --rescue --apply saves and removes it)`);
+      if (item.reason === 'ignored_data' && item.files) console.log(`  kept: ${item.path} (ignored files atris cannot rebuild: ${item.files.join(', ')})`);
+    }
     for (const item of cleared) console.log(`  ${apply ? 'cleared' : 'clear'}: ${item.path}`);
   }
   if (reviewTotal) console.log(`review: ${plural(reviewTotal, 'other build folder waits', 'other build folders wait')} for a person; \`atris worktree cleanup\` in each repo lists them`);
@@ -603,7 +631,8 @@ function guide() {
   console.log('Start reaps completed checkouts first. Cleanup preserves branches, source changes, and files git ignores, skips live work, and prunes only verified webpack caches.');
   console.log('Start clones node_modules from a matching install when package-lock.json matches; skip npm ci when it prints "deps: cloned".');
   console.log('Below 25 GB free, start reaps finished copies in every repo; below 10 GB it refuses (ATRIS_WORKTREE_REAP_BELOW_GB, ATRIS_WORKTREE_MIN_FREE_GB).');
-  console.log('A copy shipped with --merge is removed once nothing has run in it for 10 minutes (ATRIS_WORKTREE_KEEP_AFTER_SHIP=1 keeps it).');
+  console.log('A shipped copy is removed as soon as its work is merged or on origin and nothing else runs in it; if something does, a merged copy goes once it has been quiet for 10 minutes (--keep-copy or ATRIS_WORKTREE_KEEP_AFTER_SHIP=1 keeps it).');
+  console.log('The sweep reports abandoned copies with unsaved work (idle 7 days). With --rescue it saves one to commits on a new atris-rescue/ branch, pushes it, and removes the copy only after origin has it; it removes a copy only when it can prove every byte is saved, and anything unusual keeps the copy for a person. The timer never rescues. Rescues are logged in .atris/state/worktree_removals.jsonl.');
   console.log('Use `atris worktree status` to see all worktrees and dirty counts.');
   return 0;
 }
@@ -620,12 +649,14 @@ function help() {
   console.log('    --target <ref>  override the default landing target (default: branch atris-base, else origin default branch)');
   console.log('    --local         merge into the local primary checkout instead of pushing and opening a PR');
   console.log('    --no-map-refresh  skip the automatic refresh of moved map line references');
+  console.log('    --keep-copy     keep this build copy after it ships');
   console.log('    recommended verify: npm run test:fast && node --test <focused files>');
   console.log('  atris worktree status');
   console.log('  atris worktree guard [--allow-primary] [--allow-dirty]');
   console.log('  atris worktree prune [--apply]');
   console.log('  atris worktree cleanup [--apply] [--json] [--base origin/master]  reap completed checkouts and verified webpack caches');
-  console.log('  atris worktree sweep [--apply] [--json] [--workspace <dir>] [--idle-hours 2]  reap merged, idle copies in every repo');
+  console.log('  atris worktree sweep [--apply] [--json] [--workspace <dir>] [--idle-hours 2] [--rescue] [--rescue-after-days 7]');
+  console.log('    removes merged or pushed idle copies in every repo and reports abandoned ones; --rescue saves those to a new branch on origin, then removes them');
   console.log('  atris worktree sweep --install [--every 3] | --uninstall  run the sweep on a timer');
 }
 

package/lib/campaign-keep.js

@@ -35,6 +35,7 @@ function cronSchedule(seconds) {
   if (minutes === 1) return '* * * * *';
   if (minutes < 60) return `*/${minutes} * * * *`;
   const hours = Math.round(minutes / 60);
+  if (hours >= 168) return '0 0 * * 0';
   return hours >= 24 ? '0 0 * * *' : `0 */${hours} * * *`;
 }
 

package/lib/first-minute.js

@@ -8,6 +8,7 @@ const { spawnSync } = require('child_process');
 const { isGenericScratchRoot } = require('./scratch-root');
 const { resolveDefaultVerifier } = require('./default-verifier');
 const { nonFalsifyingIssue } = require('./accept-verify-gate');
+const { reconcileTaskRows } = require('./next-work-context');
 
 const FIRST_USE_COMMAND = 'atris "help me choose the first useful step for this project"';
 const FIRST_TALK_ASK = 'what do you want here';
@@ -176,8 +177,10 @@ function titlesFromTodoSection(root, section) {
   }
 }
 
-function loadLocalTasks(root = process.cwd()) {
+function loadLocalTaskState(root = process.cwd(), { taskIds = [] } = {}) {
   let dbRows = [];
+  let lookup = () => null;
+  let databaseRead = false;
   try {
     const taskDb = require('./task-db');
     // Reading never creates the db, so a first look writes nothing.
@@ -185,20 +188,52 @@ function loadLocalTasks(root = process.cwd()) {
     const db = taskDb.open();
     const workspaceRoot = taskDb.workspaceRoot(root);
     const rows = taskDb.listTasks(db, { workspaceRoot, limit: 200 });
-    if (Array.isArray(rows) && rows.length) dbRows = taskDb.withTaskDisplayRefs(rows);
+    // The visible window must not become a new numbering universe. Task
+    // commands resolve these references against the complete workspace.
+    const refRows = taskDb.listTasks(db, { workspaceRoot });
+    // Busy queues must not crowd the last outcomes out of the handoff.
+    const recent = ['done', 'failed'].flatMap((status) => taskDb.listTasks(db, { workspaceRoot, status, limit: 3, orderBy: 'updated_at' }));
+    const seen = new Set(rows.map((row) => row.id));
+    rows.push(...recent.filter((row) => !seen.has(row.id)));
+    if (Array.isArray(rows) && rows.length) dbRows = taskDb.withTaskDisplayRefs(rows, refRows);
+    databaseRead = true;
+    lookup = (id) => {
+      const row = taskDb.getTask(db, id);
+      // A foreign id in a damaged projection is not this workspace's work.
+      if (row && !taskDb.rowInWorkspace(row, workspaceRoot)) return false;
+      return row ? taskDb.withTaskDisplayRefs([row], refRows)[0] : null;
+    };
+    // A shortlist is an output budget, not authority to invent a bound job.
+    for (const id of taskIds.slice(0, 8)) {
+      if (dbRows.some((row) => row.id === id)) continue;
+      const row = lookup(id);
+      if (row) dbRows.push(row);
+    }
   } catch {
     // Fall through to the local projection. Tests and fresh folders often have no db.
   }
-  if (dbRows.some(isActionableTask)) return dbRows;
+  if (dbRows.some(isActionableTask)) return { tasks: dbRows, source: 'database' };
   const projectionPath = path.join(root, '.atris', 'state', 'tasks.projection.json');
   try {
     const parsed = JSON.parse(fs.readFileSync(projectionPath, 'utf8'));
+    if (parsed.workspace_root && path.resolve(parsed.workspace_root) !== path.resolve(require('./task-db').workspaceRoot(root))) {
+      return { tasks: dbRows, source: databaseRead ? 'database' : 'none' };
+    }
     const projected = Array.isArray(parsed.tasks) ? parsed.tasks : [];
-    if (projected.some(isActionableTask) || !dbRows.length) return projected;
+    if (projected.some(isActionableTask) || !dbRows.length) {
+      const tasks = reconcileTaskRows(dbRows, projected, lookup);
+      const known = new Set(dbRows.map((row) => row.id));
+      const unknown = tasks.some((row) => !row.id || (!known.has(row.id) && !lookup(row.id)));
+      return { tasks, source: unknown || !databaseRead ? (dbRows.length ? 'mixed' : 'projection') : 'database', generated_at: parsed.generated_at || null };
+    }
   } catch {
     // Keep any done-only db rows below.
   }
-  return dbRows;
+  return { tasks: dbRows, source: databaseRead ? 'database' : 'none' };
+}
+
+function loadLocalTasks(root = process.cwd()) {
+  return loadLocalTaskState(root).tasks;
 }
 
 function loadLatestRecap(root = process.cwd()) {
@@ -1170,6 +1205,7 @@ module.exports = {
   spokenBuiltList,
   taskStartedAt,
   loadLocalTasks,
+  loadLocalTaskState,
   firstTalkBuildCommand,
   renderWhatsNextAsk,
   isLeftoverVerbLook,

package/lib/intents.js

@@ -8,6 +8,13 @@ const INTENTS = Object.freeze([
     plain: 'your agent picks the most useful next step and starts it.',
     offer: 'boot_empty',
   }),
+  Object.freeze({
+    id: 'prioritize_work',
+    say: Object.freeze(['whats the most important work to work on', 'what should we work on next', 'what is the highest priority work', 'help me choose what to work on']),
+    do: 'atris task next --json',
+    plain: 'your agent reads the current goal, existing parts and recent evidence before recommending the next work.',
+    offer: 'always',
+  }),
   Object.freeze({
     id: 'keep_going',
     say: Object.freeze(['keep going while i\'m away', 'run overnight', 'finish this', 'keep working without me']),