atris 3.42.0 → 3.44.0

package/commands/init.js

@@ -602,9 +602,12 @@ function initAtris() {
 
 
   // Copy team members (MEMBER.md format — directory per member with skills/tools/context)
-  const starterMembers = ['navigator', 'executor', 'validator', 'mission-lead', 'improver'];
+  const starterMembers = ['navigator', 'executor', 'validator', 'mission-lead', 'improver', 'customer-lead'];
+  const starterMemberFiles = ['MEMBER.md', 'SOUL.md', 'START_HERE.md'];
+  const starterMemberDirs = ['skills', 'tools', 'context'];
   starterMembers.forEach(name => {
-    const sourceFile = path.join(__dirname, '..', 'atris', 'team', name, 'MEMBER.md');
+    const sourceMemberDir = path.join(__dirname, '..', 'atris', 'team', name);
+    const sourceFile = path.join(sourceMemberDir, 'MEMBER.md');
     const targetMemberDir = path.join(teamDir, name);
     const targetFile = path.join(targetMemberDir, 'MEMBER.md');
     const legacyFile = path.join(teamDir, `${name}.md`);
@@ -614,11 +617,17 @@ function initAtris() {
 
     if (fs.existsSync(sourceFile)) {
       fs.mkdirSync(targetMemberDir, { recursive: true });
-      fs.mkdirSync(path.join(targetMemberDir, 'skills'), { recursive: true });
-      fs.mkdirSync(path.join(targetMemberDir, 'tools'), { recursive: true });
-      fs.mkdirSync(path.join(targetMemberDir, 'context'), { recursive: true });
-      fs.copyFileSync(sourceFile, targetFile);
-      markReady('team', name, `✓ Created team/${name}/ (MEMBER.md + skills/ + tools/ + context/)`);
+      starterMemberDirs.forEach(dirName => {
+        const sourceDir = path.join(sourceMemberDir, dirName);
+        const targetDir = path.join(targetMemberDir, dirName);
+        fs.mkdirSync(targetDir, { recursive: true });
+        if (fs.existsSync(sourceDir)) fs.cpSync(sourceDir, targetDir, { recursive: true });
+      });
+      starterMemberFiles.forEach(fileName => {
+        const source = path.join(sourceMemberDir, fileName);
+        if (fs.existsSync(source)) fs.copyFileSync(source, path.join(targetMemberDir, fileName));
+      });
+      markReady('team', name, `✓ Created team/${name}/ (identity + skills/ + tools/ + context/)`);
     }
   });
 

package/commands/lesson.js

@@ -8,6 +8,7 @@ const {
 } = require('./autopilot');
 const { detectLessonContradictions } = require('../lib/lesson-contradiction');
 const taskDb = require('../lib/task-db');
+const { validateDetector, appendLedgerEntry, readLedger } = require('../lib/lesson-ledger');
 
 /**
  * Tag a lesson's line in atris/lessons.md with `[resolved]` (idempotent).
@@ -78,6 +79,14 @@ function autoResolveLessons(cwd, options = {}) {
   if (!dryRun && resolved.length) {
     const metaPath = path.join(cwd, 'atris', 'lessons.json');
     fs.writeFileSync(metaPath, JSON.stringify(metadata, null, 2) + '\n');
+    for (const slug of resolved) {
+      appendLedgerEntry(cwd, {
+        action: 'resolve',
+        slug,
+        evidence: `detector passed: ${metadata[slug].detector}`,
+        outcome: `status resolved, resolved_at ${today}`,
+      });
+    }
   }
 
   return { checked, resolved, dryRun };
@@ -213,12 +222,138 @@ function mineLessons(args) {
   }
 }
 
+/**
+ * Strip the `[resolved]` tag from a lesson's line in atris/lessons.md.
+ * Inverse of tagLessonResolvedInMd; used by revert.
+ * @returns {boolean} true if the file was changed.
+ */
+function untagLessonResolvedInMd(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;
+    lines[i] = lines[i].replace(/\[resolved\]\s*/i, '');
+    changed = true;
+  }
+  if (changed) fs.writeFileSync(lessonsPath, lines.join('\n'));
+  return changed;
+}
+
+/**
+ * Add a lesson as a validated contract in one step: prose line in lessons.md,
+ * typed entry in the lessons.json sidecar, and a ledger record with evidence.
+ *
+ * When a detector is given it must actually run (see validateDetector):
+ * a lesson whose falsifier is a typo would sit unresolvable forever and rot
+ * trust in the whole file. Detector-less adds are still allowed (process
+ * notes), they just never self-retire.
+ *
+ * @param {string} cwd
+ * @param {string} slug kebab-case
+ * @param {'pass'|'fail'} status
+ * @param {string} explanation
+ * @param {{ detector?: string, scope?: string }} [opts]
+ * @returns {{ ok: boolean, error?: string, ledger?: object }}
+ */
+function addLesson(cwd, slug, status, explanation, opts = {}) {
+  let evidence = 'prose-only (no detector)';
+  if (opts.detector !== undefined) {
+    const check = validateDetector(opts.detector, cwd);
+    if (!check.ok) {
+      return { ok: false, error: `detector rejected: ${check.reason}` };
+    }
+    evidence = `detector validated (exit ${check.exitCode}): ${opts.detector}`;
+  }
+
+  writeLesson(cwd, slug, status, explanation);
+
+  if (opts.detector !== undefined || opts.scope !== undefined) {
+    const metadata = loadLessonMetadata(cwd);
+    metadata[slug] = {
+      ...(metadata[slug] || {}),
+      ...(opts.detector !== undefined ? { detector: opts.detector } : {}),
+      ...(opts.scope !== undefined ? { scope: opts.scope } : {}),
+      status: (metadata[slug] && metadata[slug].status) || 'open',
+    };
+    fs.writeFileSync(
+      path.join(cwd, 'atris', 'lessons.json'),
+      JSON.stringify(metadata, null, 2) + '\n'
+    );
+  }
+
+  const ledger = appendLedgerEntry(cwd, {
+    action: 'add',
+    slug,
+    evidence,
+    outcome: `${status} lesson written`,
+  });
+  return { ok: true, ledger };
+}
+
+/**
+ * Reopen a resolved lesson: sidecar back to open, [resolved] tag stripped,
+ * revert recorded in the ledger. The rollback half of auto-resolve: a
+ * detector that passed for the wrong reason (deleted call site, gamed check)
+ * must be reversible without hand-editing two files.
+ * @returns {{ ok: boolean, error?: string, ledger?: object }}
+ */
+function revertLessonResolution(cwd, slug, reason) {
+  const metadata = loadLessonMetadata(cwd);
+  const meta = metadata[slug];
+  if (!meta) return { ok: false, error: `no sidecar entry for "${slug}"` };
+  if (meta.status !== 'resolved') {
+    return { ok: false, error: `"${slug}" is not resolved (status: ${meta.status || 'open'})` };
+  }
+  const prevResolvedAt = meta.resolved_at;
+  delete meta.resolved_at;
+  meta.status = 'open';
+  metadata[slug] = meta;
+  fs.writeFileSync(
+    path.join(cwd, 'atris', 'lessons.json'),
+    JSON.stringify(metadata, null, 2) + '\n'
+  );
+  untagLessonResolvedInMd(cwd, slug);
+  const ledger = appendLedgerEntry(cwd, {
+    action: 'revert',
+    slug,
+    evidence: reason || 'manual revert',
+    outcome: `reopened (was resolved ${prevResolvedAt || 'unknown'})`,
+  });
+  return { ok: true, ledger };
+}
+
+function showLedger(args) {
+  const cwd = process.cwd();
+  const json = args.includes('--json');
+  const limitIdx = args.indexOf('--limit');
+  const limit = limitIdx !== -1 ? parseInt(args[limitIdx + 1], 10) || 20 : 20;
+  const records = readLedger(cwd, { limit });
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, action: 'lesson_ledger', count: records.length, records }, null, 2));
+    return;
+  }
+  if (!records.length) {
+    console.log('ledger is empty (no lesson mutations recorded yet)');
+    return;
+  }
+  for (const r of records) {
+    console.log(`${(r.ts || '').slice(0, 16)} ${r.action.padEnd(7)} ${r.slug}: ${r.evidence || ''}`);
+  }
+}
+
 function printLessonUsage() {
   console.log('');
-  console.log('  Usage: atris lesson add <slug> <pass|fail> "<text>"');
+  console.log('  Usage: atris lesson add <slug> <pass|fail> "<text>" [--detector "<cmd>"] [--scope <scope>]');
   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('         atris lesson revert <slug> ["<reason>"]');
+  console.log('         atris lesson ledger [--json] [--limit N]');
   console.log('');
 }
 
@@ -251,12 +386,44 @@ function lessonAtris(subcommand, ...args) {
     return;
   }
 
+  if (subcommand === 'ledger') {
+    showLedger(args);
+    return;
+  }
+
+  if (subcommand === 'revert') {
+    const [slug, ...reasonParts] = args;
+    if (!slug) {
+      console.error('  ✗ usage: atris lesson revert <slug> ["<reason>"]');
+      process.exit(1);
+    }
+    const res = revertLessonResolution(process.cwd(), slug, reasonParts.join(' ').trim() || undefined);
+    if (!res.ok) {
+      console.error(`  ✗ ${res.error}`);
+      process.exit(1);
+    }
+    console.log(`✓ lesson reopened: ${slug} (ledger ${res.ledger.id})`);
+    return;
+  }
+
   if (subcommand !== 'add') {
     printLessonUsage();
     process.exit(subcommand ? 1 : 0);
   }
 
-  const [slug, status, ...messageParts] = args;
+  // Pull --detector/--scope flag pairs out before positional parsing.
+  const opts = {};
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--detector') {
+      opts.detector = args[++i];
+    } else if (args[i] === '--scope') {
+      opts.scope = args[++i];
+    } else {
+      positional.push(args[i]);
+    }
+  }
+  const [slug, status, ...messageParts] = positional;
   const explanation = messageParts.join(' ').trim();
 
   if (!slug || !/^[a-z0-9-]+$/.test(slug)) {
@@ -274,9 +441,16 @@ function lessonAtris(subcommand, ...args) {
     process.exit(1);
   }
 
-  writeLesson(process.cwd(), slug, status, explanation);
-  console.log(`✓ lesson added: ${slug} (${status})`);
+  const res = addLesson(process.cwd(), slug, status, explanation, opts);
+  if (!res.ok) {
+    console.error(`  ✗ ${res.error}`);
+    process.exit(1);
+  }
+  const typed = opts.detector ? ' [detector validated]' : '';
+  console.log(`✓ lesson added: ${slug} (${status})${typed}`);
 }
 
 module.exports = lessonAtris;
 module.exports.autoResolveLessons = autoResolveLessons;
+module.exports.addLesson = addLesson;
+module.exports.revertLessonResolution = revertLessonResolution;

package/commands/mission.js

@@ -46,6 +46,7 @@ const {
   renderEmailLine,
   renderMorningCardRow,
 } = require('../lib/receipt-block');
+const { findCachedMissionStepReceipt } = require('../lib/receipt-evidence');
 const {
   pruneRuns,
   runsPruneLines,
@@ -79,7 +80,7 @@ const {
   missionVerifierTimeoutMs,
   resolveDefaultVerifier,
 } = require('../lib/default-verifier');
-const { redirectToWorkspaceRoot } = require('../lib/mission-root');
+const { resolveWorkspaceRoot, redirectToWorkspaceRoot } = require('../lib/mission-root');
 const { readJson, writeJson } = require('../lib/json-file');
 const {
   normalizeHumanAsks,
@@ -908,6 +909,11 @@ function loadMissionMap(root = process.cwd()) {
   return map;
 }
 
+function hasLocalMissionState(root = process.cwd()) {
+  return readJsonLines(statePaths(root).missionsJsonl)
+    .some((mission) => mission && mission.id && mission.cloud !== true);
+}
+
 function terminalNextAction(status) {
   if (status === 'complete') return 'mission complete';
   if (status === 'stopped') return 'mission stopped';
@@ -9151,6 +9157,8 @@ async function executeMissionRunTicksPhase(context) {
       const tickStart = stampIso();
       const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
       let result = { status: 'skipped', reason: 'unknown', tick_index: tickIdx, ran: false, started_at: tickStart };
+      let cachedStep = findCachedMissionStepReceipt(cwd, { missionId: mission.id, tickIndex: tickIdx });
+      let cachedVerifierResult = cachedStep ? cachedStep.verifier_result : null;
       const tickSelection = resolveMissionTickRunner(runtimeMission, cwd);
       const tickRuntimeMission = tickSelection.mission;
       const tickRunnerName = String(tickRuntimeMission.runner || '').trim().toLowerCase();
@@ -9182,7 +9190,17 @@ async function executeMissionRunTicksPhase(context) {
       }
 
       // Active-hours gate
-      if (engineBackedTick && !tickEngineId) {
+      if (cachedStep) {
+        result = {
+          ...result,
+          ...cachedStep.tick,
+          tick_index: tickIdx,
+          cached: true,
+          reason: 'receipt-cache-hit',
+          ran: cachedStep.tick.ran !== false,
+          status: cachedStep.tick.status || 'ran',
+        };
+      } else if (engineBackedTick && !tickEngineId) {
         result = { ...result, status: 'errored', reason: 'no-ready-engine' };
       } else if (!isWithinActiveHours(mission.active_hours)) {
         result = { ...result, status: 'skipped', reason: 'quiet-hours' };
@@ -9399,7 +9417,7 @@ async function executeMissionRunTicksPhase(context) {
         }
       }
 
-      if (tickEngineId) {
+      if (tickEngineId && !cachedStep) {
         result.rate_limit_info = lastRateLimit;
         const engineHealth = recordMissionEngineTickOutcome(tickEngineId, result, cwd);
         if (engineHealth) result.engine_health = engineHealth.health;
@@ -9415,12 +9433,18 @@ async function executeMissionRunTicksPhase(context) {
         tickIdx,
         frozen,
       };
-      await verifyMissionRunTickPhase(context);
-      result = context.currentTick.result;
-      const verifierResult = context.currentTick.verifierResult;
+      let verifierResult = null;
+      if (cachedStep) {
+        verifierResult = cachedVerifierResult;
+        if (verifierResult) result.verifier_passed = verifierResult.passed;
+      } else {
+        await verifyMissionRunTickPhase(context);
+        result = context.currentTick.result;
+        verifierResult = context.currentTick.verifierResult;
+      }
       pauseReason = context.pauseReason;
       context.currentTick = null;
-      let receiptPath = null;
+      let receiptPath = cachedStep ? cachedStep.receipt_path : null;
 
       // Review-lane drain: always-on loops sweep the agent-safe review actions
       // each tick so proof-backed work reaches certified on cadence with zero
@@ -9430,27 +9454,32 @@ async function executeMissionRunTicksPhase(context) {
           ? { skipped: true, reason: 'no-drain-flag' }
           : runReviewLaneDrain(cwd);
       }
-      const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier, baseline: runWorktreeBaseline });
+      const tickWorktree = cachedStep?.tick?.worktree
+        || worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier, baseline: runWorktreeBaseline });
 
       // Layer classification needs the receipt text AND the worktree receipt, so it
       // runs here — after both exist — covering the claude and atris2 branches alike.
-      const tickReceiptText = result.atris2?.receipt_text || result.claude?.receipt_text || result.drill?.receipt_text || '';
-      const layerInfo = extractLayerFromReceiptText(tickReceiptText, tickWorktree?.new_since_baseline_sample);
-      result.layer = layerInfo.layer;
-      result.layer_source = layerInfo.source;
+      if (!(cachedStep && cachedStep.tick && cachedStep.tick.layer)) {
+        const tickReceiptText = result.atris2?.receipt_text || result.claude?.receipt_text || result.drill?.receipt_text || '';
+        const layerInfo = extractLayerFromReceiptText(tickReceiptText, tickWorktree?.new_since_baseline_sample);
+        result.layer = layerInfo.layer;
+        result.layer_source = layerInfo.source;
+      }
 
       // Persist tick to mission state + write structured receipt
       const finishedAt = stampIso();
-      const tickRecord = { ...result, started_at: tickStart, finished_at: finishedAt, worktree: tickWorktree };
+      const tickRecord = { ...result, started_at: result.started_at || tickStart, finished_at: result.finished_at || finishedAt, worktree: tickWorktree };
       ticks.push(tickRecord);
-      receiptPath = writeReceipt(runtimeMission, {
-        kind: 'mission_run_tick',
-        tick: tickRecord,
-        frozen,
-        verifier_result: verifierResult,
-        rate_limit_info: lastRateLimit,
-        worktree: tickWorktree,
-      });
+      if (!receiptPath) {
+        receiptPath = writeReceipt(runtimeMission, {
+          kind: 'mission_run_tick',
+          tick: tickRecord,
+          frozen,
+          verifier_result: verifierResult,
+          rate_limit_info: lastRateLimit,
+          worktree: tickWorktree,
+        });
+      }
 
       const xpReadyAction = missionXpReadyAction(mission, receiptPath);
       const budgetRemainingSeconds = missionFullBudgetRemainingSeconds(mission);
@@ -9938,56 +9967,72 @@ function tickMission(args) {
     const tickStart = stampIso();
     const lastTickIndex = Number(mission.last_tick_index || 0);
     const tickIdx = lastTickIndex + 1;
-    const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
-    const worktreeBaseline = loadMissionWorktreeBaseline(mission.id, cwd);
-    const protectedLaneGuard = inspectMissionTickProtectedDiff(mission, tickWorktreeBefore, cwd);
-
+    // Interrupt between writeReceipt and saveMission leaves a completed receipt
+    // for this tick_index while last_tick_index stays behind. Reuse it on resume
+    // instead of re-deriving the step from scratch.
+    const cachedStep = findCachedMissionStepReceipt(cwd, { missionId: mission.id, tickIndex: tickIdx });
     const effectiveVerifier = effectiveMissionVerifier(mission);
     const verifierCommand = verify
       ? String(verifyOverride || effectiveVerifier || '').trim()
       : '';
-    if (verifierCommand) assertMissionVerifier(verifierCommand, asJson);
+    if (!cachedStep && verifierCommand) assertMissionVerifier(verifierCommand, asJson);
 
     let verifierResult = null;
-    if (protectedLaneGuard.allowed && verify && verifierCommand) {
-      verifierResult = runVerifier(verifierCommand);
-    }
-    const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: verifierCommand || effectiveVerifier, baseline: worktreeBaseline });
-
-    // Same layer classification as the run-tick path; manual ticks carry their
-    // receipt text in --summary.
-    const layerInfo = extractLayerFromReceiptText(summary || '', tickWorktree?.new_since_baseline_sample);
-    const guardPauseReason = protectedLaneGuard.unreadable
-      ? 'mission-diff-unreadable'
-      : 'protected-lane-review';
-    const tickRecord = {
-      status: protectedLaneGuard.allowed ? 'ran' : protectedLaneGuard.status,
-      reason: protectedLaneGuard.allowed ? 'tick-recorded' : guardPauseReason,
-      tick_index: tickIdx,
-      ran: protectedLaneGuard.allowed,
-      started_at: tickStart,
-      claude: { skipped: true, reason: 'orchestrator-is-caller-session' },
-      summary: summary || null,
-      layer: layerInfo.layer,
-      layer_source: layerInfo.source,
-      verifier_passed: verifierResult ? !!verifierResult.passed : null,
-      protected_lane_guard: protectedLaneGuard,
-      finished_at: stampIso(),
-      worktree: tickWorktree,
-    };
-    const receiptPath = writeReceipt(mission, {
-      kind: 'mission_tick',
-      tick: tickRecord,
-      frozen: {
-        verifier: verifierCommand || effectiveVerifier || '',
-        lane: mission.lane || 'workspace',
+    let tickRecord = null;
+    let receiptPath = null;
+    if (cachedStep) {
+      tickRecord = {
+        ...cachedStep.tick,
+        cached: true,
+        reason: 'receipt-cache-hit',
+      };
+      verifierResult = cachedStep.verifier_result;
+      receiptPath = cachedStep.receipt_path;
+    } else {
+      const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
+      const worktreeBaseline = loadMissionWorktreeBaseline(mission.id, cwd);
+      const protectedLaneGuard = inspectMissionTickProtectedDiff(mission, tickWorktreeBefore, cwd);
+
+      if (protectedLaneGuard.allowed && verify && verifierCommand) {
+        verifierResult = runVerifier(verifierCommand);
+      }
+      const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: verifierCommand || effectiveVerifier, baseline: worktreeBaseline });
+
+      // Same layer classification as the run-tick path; manual ticks carry their
+      // receipt text in --summary.
+      const layerInfo = extractLayerFromReceiptText(summary || '', tickWorktree?.new_since_baseline_sample);
+      const guardPauseReason = protectedLaneGuard.unreadable
+        ? 'mission-diff-unreadable'
+        : 'protected-lane-review';
+      tickRecord = {
+        status: protectedLaneGuard.allowed ? 'ran' : protectedLaneGuard.status,
+        reason: protectedLaneGuard.allowed ? 'tick-recorded' : guardPauseReason,
+        tick_index: tickIdx,
+        ran: protectedLaneGuard.allowed,
         started_at: tickStart,
-      },
-      verifier_result: verifierResult,
-      protected_lane_guard: protectedLaneGuard,
-      rate_limit_info: null,
-      worktree: tickWorktree,
-    });
+        claude: { skipped: true, reason: 'orchestrator-is-caller-session' },
+        summary: summary || null,
+        layer: layerInfo.layer,
+        layer_source: layerInfo.source,
+        verifier_passed: verifierResult ? !!verifierResult.passed : null,
+        protected_lane_guard: protectedLaneGuard,
+        finished_at: stampIso(),
+        worktree: tickWorktree,
+      };
+      receiptPath = writeReceipt(mission, {
+        kind: 'mission_tick',
+        tick: tickRecord,
+        frozen: {
+          verifier: verifierCommand || effectiveVerifier || '',
+          lane: mission.lane || 'workspace',
+          started_at: tickStart,
+        },
+        verifier_result: verifierResult,
+        protected_lane_guard: protectedLaneGuard,
+        rate_limit_info: null,
+        worktree: tickWorktree,
+      });
+    }
 
 	    let status = 'running';
 	    let nextAction = (verifierCommand || effectiveVerifier)
@@ -9995,7 +10040,8 @@ function tickMission(args) {
 	      : (mission.always_on && missionTaskSpine(mission)?.has_task
 	        ? nextCandidateTickAction(mission)
 	        : 'attach task, verifier, or proof');
-	    const nextGoalChain = advanceMissionGoalChain(mission.goal_chain, summary, verifierResult);
+	    const nextGoalChain = advanceMissionGoalChain(mission.goal_chain, summary || tickRecord.summary, verifierResult);
+	    const protectedLaneGuard = tickRecord.protected_lane_guard || { allowed: true };
 	    if (!protectedLaneGuard.allowed) {
 	      status = 'paused';
 	      nextAction = protectedLaneGuard.unreadable
@@ -10072,9 +10118,10 @@ function tickMission(args) {
     const atrisGoalState = refreshAtrisGoalController(process.cwd(), { missionId: outputMission.id });
     const codexGoalState = refreshCodexGoalController(process.cwd());
     printJsonOrText(
-      { ok: true, action: 'mission_tick', mission: outputMission, tick: tickRecord, verifier_result: verifierResult, blocker, receipt_path: receiptPath, log_path: logPath, atris_goal_state: atrisGoalState, codex_goal_state: codexGoalState, continuation_goal: continuationGoal, operator_summary_warning: operatorSummaryWarning },
+      { ok: true, action: 'mission_tick', mission: outputMission, tick: tickRecord, verifier_result: verifierResult, blocker, receipt_path: receiptPath, log_path: logPath, atris_goal_state: atrisGoalState, codex_goal_state: codexGoalState, continuation_goal: continuationGoal, operator_summary_warning: operatorSummaryWarning, cached: Boolean(tickRecord.cached) },
       [
-        ...missionTickResultLines(outputMission, tickIdx, receiptPath, verifierResult, summary),
+        ...(tickRecord.cached ? [`Reused receipt for tick ${tickIdx}: ${receiptPath}`] : []),
+        ...missionTickResultLines(outputMission, tickIdx, receiptPath, verifierResult, summary || tickRecord.summary),
         ...(missionBlockerReceiptLine(blocker) ? [missionBlockerReceiptLine(blocker)] : []),
         ...(continuationGoal?.mission ? [`Next goal: ${continuationGoal.mission.objective}`] : []),
       ],
@@ -11026,8 +11073,16 @@ function answerMissionHumanAsk(ref, askIndex, answer, note = '') {
 }
 
 function missionCommand(args) {
-  const subcommand = args[0] || 'status';
-  const rest = args.slice(1);
+  const simpleCardArgs = args.filter((value) => value !== '--json');
+  const isBareMission = simpleCardArgs.length === 0;
+  if (args[0] === 'answer') {
+    return require('./human-missions').answerCommand(args.slice(1));
+  }
+  if (isBareMission && !hasLocalMissionState(resolveWorkspaceRoot())) {
+    return require('./human-missions').currentMissionCommand(args);
+  }
+  const subcommand = isBareMission ? 'status' : (args[0] || 'status');
+  const rest = isBareMission ? args : args.slice(1);
   // Every mission verb resolves its state store from process.cwd(). Running one
   // from a subdirectory used to create a nested .atris store the fleet never
   // reads (proven footgun: a nested .atris appeared under

package/commands/slop.js

@@ -134,10 +134,12 @@ function addProjectRule(rule, root = process.cwd()) {
 }
 
 // Map<absFile, Set<changedLineNumber>> from the working-tree (or --cached) git diff.
-function gitChangedLines(staged, cwd = process.cwd()) {
+function gitChangedLines(staged, cwd = process.cwd(), range = null) {
   const map = new Map();
   let out;
-  try { out = execFileSync('git', ['diff', '--unified=0', ...(staged ? ['--cached'] : [])], { encoding: 'utf8', cwd }); }
+  try {
+    out = execFileSync('git', ['diff', '--unified=0', ...(staged ? ['--cached'] : []), ...(range ? [range] : [])], { encoding: 'utf8', cwd });
+  }
   catch { return map; }
   let cur = null;
   for (const line of out.split('\n')) {
@@ -239,6 +241,35 @@ function scanFile(file, rules = RULES, pairRules = PAIR_RULES) {
   return findings;
 }
 
+// Programmatic scanner for landing gates. Callers provide the exact candidate
+// paths, so this never widens into a repo scan. An optional changed-lines map
+// keeps branch-diff gates on the lines the candidate actually added or edited.
+function scanPaths(targets, options = {}) {
+  const root = path.resolve(options.root || process.cwd());
+  const rules = options.rules || RULES.concat(loadProjectRules(root));
+  const pairRules = options.pairRules || PAIR_RULES;
+  const changedLines = options.changedLines instanceof Map ? options.changedLines : null;
+  const seen = new Set();
+  const files = [];
+  for (const target of Array.isArray(targets) ? targets : [targets]) {
+    if (!target) continue;
+    for (const file of walk(path.resolve(root, target), [])) {
+      const absolute = path.resolve(file);
+      if (seen.has(absolute)) continue;
+      seen.add(absolute);
+      files.push(absolute);
+    }
+  }
+  let findings = files.flatMap((file) => scanFile(file, rules, pairRules));
+  if (changedLines) {
+    findings = findings.filter((finding) => {
+      const lines = changedLines.get(path.resolve(finding.file));
+      return lines && lines.has(finding.line);
+    });
+  }
+  return { root, files, findings };
+}
+
 function detect(argv) {
   const json = argv.includes('--json');
   const quiet = argv.includes('--quiet');
@@ -583,4 +614,4 @@ function slopCommand(argv) {
   return 0;
 }
 
-module.exports = { slopCommand, detect, scanFile, RULES, PAIR_RULES, loadProjectRules, addProjectRule, gitChangedLines, applyFixes, installHook, findDeadCode, findOrphanedExports, listJsFiles };
+module.exports = { slopCommand, detect, scanFile, scanPaths, RULES, PAIR_RULES, loadProjectRules, addProjectRule, gitChangedLines, applyFixes, installHook, findDeadCode, findOrphanedExports, listJsFiles };