atris 3.71.1 → 3.71.2

package/atris/skills/campaigns/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: campaigns
-description: "Run an Atris campaign: a long goal with a judge that fails today, a budget, and members in seats, worked by missions until the judge passes. Use when the goal takes many runs, needs several members, or must spend under a cap. Triggers on: run a campaign, long goal, big goal, keep going until it passes, campaign, judge, budget, atris campaign."
+description: "Run an Atris campaign: a long goal (hours to days) with a judge that fails today and members in seats, worked by missions until the judge passes. Use only when the path is unknown and takes many tries; a quick fix or a single mission is not a campaign. Triggers on: run a campaign, long goal, big goal, keep going until it passes, campaign, judge, budget, atris campaign."
 version: 1.0.0
 tags:
   - campaign
@@ -12,14 +12,18 @@ tags:
 
 # Campaigns
 
-A campaign is a goal plus a judge. The judge is a command that exits 0 only when the goal is met. The campaign runs missions under a budget until the judge passes, the money runs out, or a person has to decide something.
+A campaign is a goal plus a judge. The judge is a command that exits 0 only when the goal is met. The campaign runs missions until the judge passes, a budget (cloud only) runs out, or a person has to decide something.
 
-## Campaign or mission
+## Size it first
 
-- **Mission**: one member, one objective, one check. Done in a run or a few ticks.
-- **Campaign**: the goal needs many missions, more than one member, or a spending cap. A campaign decides what to do next; its missions do the work.
+Ask one question: do you already know the steps?
 
-If one `atris mission start` would finish it, use a mission.
+- **Quick fix** (minutes): you know the file and the fix. Edit it, run the tests that cover it, ship. No mission, no judge.
+- **Mission** (an hour or a few): you know what done looks like and roughly how. One `atris mission start`, or a few across members.
+- **Campaign** (hours to days): done is clear and measurable, the path is not, and it takes many tries. A campaign decides what to do next; its missions do the work.
+- **Purpose** (months to years): a standing campaign (`--standing`). Campaigns run under it (`--parent`), and each one's lessons feed the next.
+
+A campaign is a vision, not a fix. If one mission would finish it, use a mission; if you could write the diff in ten minutes, write it. Measured 2026-10-16: a 50-line fix run as a campaign took six jobs and 29 minutes.
 
 ## The five commands
 

package/atris.md

@@ -131,6 +131,7 @@ Six primitives, one sentence each:
 - **The Mission** (MISSION.md): the enduring purpose. Never ends. Sits at the top and helps members pick goals.
 - **Goals** (endgame, member goals): direction derived from the Mission. A goal points; it does not commit.
 - **A mission run** (`atris mission`): a goal that signed a contract: objective + owner + verifier + stop condition. Ends in hours or days. Any engine can tick it.
+- **A campaign** (`atris campaign`): a measurable goal with a judge that fails today, worked by many mission runs until it passes. Hours to days.
 - **Tasks** (`atris task`): the smallest provable units. Receipts, then human accept.
 - **Members** (`atris member`): the WHO. A role with memory and judgment doing one bounded, proven slice at a time.
 - **Loops** (`atris loops`): the WHEN. Clocks that never finish, only fire. Health is exit 0 on cadence.
@@ -236,6 +237,14 @@ Before picking up work, decide scope:
 - single project → route to that project's `atris/team/` and `atris task` queue
 - crosses projects → route to `atris/team/cross-project-architect/` and plan the dependency order first
 
+Then size it, before any tool runs. Ask one question: do I already know the steps?
+- **Quick fix** (minutes): you know the file and the fix. Do it, run the tests that cover it, ship. No mission, no judge.
+- **Mission** (an hour or a few): you know what done looks like and roughly how. One mission run, or a few across members (builder builds, validator checks).
+- **Campaign** (hours to days): done is clear and measurable, the path is not, and it takes many tries. `atris campaign` with a judge that fails today; its missions do the work.
+- **Purpose** (months to years): a standing campaign under the Mission. Its judge runs on a schedule, campaigns run under it, and each one's lessons and scored record feed the next. This is the self-improving loop.
+
+Never size up for show. A fix run as a campaign wastes time and inference and leaves bad data (2026-10-16: a 50-line fix run as a campaign took six jobs and 29 minutes). Sizing is judgment, not a command: `atris wish` is for imagining, not for sizing.
+
 The human is the constructor. You multiply. Handoff fidelity lives in the files, not in context.
 
 ## next

package/commands/campaign.js

@@ -11,12 +11,12 @@ const path = require('path');
 const { spawn } = require('child_process');
 const { readFlag } = require('../lib/arg-parser');
 const { CAMPAIGN_ID, isHumanActor, validateCampaign } = require('../lib/campaign-schema');
-const { decide } = require('../lib/campaign-core');
+const { decide, paysDollars } = require('../lib/campaign-core');
 const { campaignDbPath, getCampaign, listCampaigns, newCampaignId, openCampaignStore } = require('../lib/campaign-store');
 const { findHoldout, moveHoldoutBack, moveHoldoutIn, scrub } = require('../lib/campaign-holdout');
 const { judgeRanData, judgeReading, outputTail } = require('../lib/campaign-reading');
 const { CLOUD_FEATURES, cloudLink, cloudRunStatus, runInCloud, sendPersonAction, syncCampaign, takeCampaignToken } = require('../lib/campaign-sync');
-const { campaignHome, changedProtected, checkoutTop, planProtect, readProtect, saveProtect } = require('../lib/campaign-protect');
+const { campaignHome, changedProtected, checkoutTop, headCommit, planProtect, readProtect, saveProtect } = require('../lib/campaign-protect');
 
 const JUDGE_TIMEOUT_SECONDS = 15 * 60;
 // Who pays for a campaign's engines (atris/features/campaign/api.md, Credits).
@@ -211,6 +211,13 @@ function keepJudgeScript(judge, folder) {
   return { from: file, judge: shellQuote(copy) };
 }
 
+// The commit saved on a campaign's start, or null when it started outside git.
+function savedStartCommit(store, campaignId) {
+  if (!campaignId) return null;
+  const start = store.read(campaignId).find((event) => event.type === 'campaign_started');
+  return (start && start.data && start.data.start_commit) || null;
+}
+
 function makeContext(args, deps) {
   const asJson = args.includes('--json');
   const store = deps.store || openCampaignStore(process.cwd());
@@ -220,10 +227,15 @@ function makeContext(args, deps) {
   // Held-out files live beside the campaign store, outside every checkout.
   const holdoutRoot = deps.holdoutRoot || path.dirname(store.path || campaignDbPath());
   // A campaign with a held-out file hands its path to the judge, and nothing
-  // the judge prints from it reaches the store.
-  const judge = async (command, timeout, campaignId) => {
+  // the judge prints from it reaches the store. A campaign started in a git
+  // checkout hands the judge the commit it started from. Start passes its
+  // commit in, since nothing is saved yet.
+  const judge = async (command, timeout, campaignId, startCommit = savedStartCommit(store, campaignId)) => {
     const holdout = campaignId ? findHoldout(holdoutRoot, campaignId) : null;
-    const reading = await runJudge(command, timeout, holdout ? { ...process.env, ATRIS_CAMPAIGN_HOLDOUT: holdout } : process.env);
+    const env = { ...process.env };
+    if (holdout) env.ATRIS_CAMPAIGN_HOLDOUT = holdout;
+    if (startCommit) env.ATRIS_CAMPAIGN_START_COMMIT = startCommit;
+    const reading = await runJudge(command, timeout, env);
     if (!holdout) return reading;
     return { ...reading, summary: scrub(reading.summary, holdout), output_tail: scrub(reading.output_tail, holdout) };
   };
@@ -250,6 +262,14 @@ function requireCampaign(ctx, id) {
   return { view };
 }
 
+// On a subscription the budget is still a cap, measured at API prices, so the
+// person sees how much of it is used without a dollar figure they never paid.
+function spentText(view, paid) {
+  if (paid) return `${money(view.budget.spent)} spent of ${money(view.budget.total)}`;
+  const used = view.budget.total > 0 ? Math.round((view.budget.spent / view.budget.total) * 100) : 0;
+  return `on your subscription, nothing spent · ${used}% of the budget used`;
+}
+
 function renderList(views) {
   if (!views.length) {
     return 'No campaigns yet. Start one:\n  atris campaign "<goal as a sentence>" --judge "<command that fails today>"';
@@ -259,7 +279,7 @@ function renderList(views) {
   for (const view of sorted) {
     const running = view.missions.filter((m) => m.status === 'running').length;
     lines.push(`${clip(view.title)}  (${view.id})`);
-    const spend = noLimit(view) ? '' : ` · ${money(view.budget.spent)} of ${money(view.budget.total)}`;
+    const spend = noLimit(view) ? '' : ` · ${spentText(view, paysDollars(view))}`;
     lines.push(`  ${view.state.replace(/_/g, ' ')}${spend} · ${running} mission${running === 1 ? '' : 's'} running · answer ${view.answer.confidence}`);
     lines.push(`  next: ${nextMove(view).text}`);
   }
@@ -274,14 +294,17 @@ function renderShow(view) {
   const last = view.last_judge;
   row('judge', `${view.judge}${last ? ` · last run ${last.passed ? 'passed' : 'failed'} at ${last.at}` : ' · never run'}${view.judge_due && last ? ' · due again' : ''}`);
   row('answer', `${view.answer.confidence}${view.answer.text ? `: ${view.answer.text}` : ''}`);
-  if (!noLimit(view)) row('budget', `${money(view.budget.spent)} spent of ${money(view.budget.total)} · ${money(view.budget.reserved)} reserved · ${money(view.budget.available)} left`);
+  if (!noLimit(view)) {
+    const paid = paysDollars(view);
+    row('budget', paid ? `${spentText(view, paid)} · ${money(view.budget.reserved)} reserved · ${money(view.budget.available)} left` : spentText(view, paid));
+  }
   row('owner', view.owner + (view.standing ? ' · standing (a passing judge means healthy, not done)' : ''));
   if (view.bet) row('bet', `${view.bet.text}${view.bet.wrong_if ? ` · wrong if ${view.bet.wrong_if}` : ''}`);
   if (view.parent) row('parent', view.parent);
   row('seats', view.seats.length ? view.seats.map((s) => (s.role ? `${s.member} (${s.role})` : s.member)).join(', ') : 'none');
   row('missions', view.missions.length ? '' : 'none');
   for (const m of view.missions) {
-    const cost = m.cost_usd === null ? '' : ` · ${money(m.cost_usd)}`;
+    const cost = m.cost_usd === null || !paysDollars(view) ? '' : ` · ${money(m.cost_usd)}`;
     lines.push(`  ${m.id.padEnd(22)} ${m.status.padEnd(8)} ${m.member || '-'}${m.outcome ? ` · ${m.outcome}` : ''}${cost}`);
   }
   row('asks', view.asks.length ? '' : 'none');
@@ -352,7 +375,8 @@ async function cmdStart(args, ctx) {
 
   const timeout = Number(readFlag(args, '--timeout', '')) || JUDGE_TIMEOUT_SECONDS;
   if (!ctx.asJson) console.error(`running the judge first: ${judge}`);
-  const reading = await ctx.judge(judge, timeout, id);
+  const startCommit = headCommit(process.cwd());
+  const reading = await ctx.judge(judge, timeout, id, startCommit);
   if (reading.passed && !standing) {
     moveHoldoutBack(held);
     return ctx.fail(`already done: the judge passes before any work (${reading.summary || 'exit 0'}). Write a judge that fails first.`, 1);
@@ -371,6 +395,7 @@ async function cmdStart(args, ctx) {
   if (bet && !wrongIf) startData.bet = bet;
   if (standing) startData.standing = true;
   if (basis) startData.basis = basis;
+  if (startCommit) startData.start_commit = startCommit;
   ctx.append(id, 'campaign_started', startData);
   if (bet && wrongIf) ctx.append(id, 'bet_set', { bet, wrong_if: wrongIf });
   if (parent) ctx.append(id, 'attached', { parent_id: parent });

package/commands/mission.js

@@ -6989,18 +6989,34 @@ const CLAUDE_SESSION_CONTEXT_ROTATE_TICKS = Math.max(
 // before the tick fires. Same tag-plus-text routing the task lane uses
 // (CLI-1189). An operator override is explicit: protected_lane_ack in the
 // mission metadata, set by a human, or ATRIS_ALLOW_PROTECTED_MISSION=1.
-function missionProtectedLaneHold(mission) {
+function missionProtectedLaneHold(mission, root = process.cwd()) {
   if (process.env.ATRIS_ALLOW_PROTECTED_MISSION === '1') return null;
   if (mission?.metadata?.protected_lane_ack) return null;
   const { DENIED_TAGS } = require('../lib/fleet');
   const { declaredProtectedLane, sniffedProtectedLane } = require('../lib/auto-accept-certified');
   const lane = String(mission?.lane || '').toLowerCase();
-  if (DENIED_TAGS.includes(lane)) return { pause_reason: `protected-lane-${lane}` };
   const probe = { title: mission?.objective, objective: mission?.stop_condition, metadata: mission?.metadata || {} };
-  if (declaredProtectedLane(probe)) return { pause_reason: 'protected-lane-declared' };
-  const sniffed = sniffedProtectedLane(probe);
-  if (sniffed) return { pause_reason: `protected-lane-${sniffed.lane}` };
-  return null;
+  let hold = null;
+  if (DENIED_TAGS.includes(lane)) hold = { pause_reason: `protected-lane-${lane}`, lane };
+  else if (declaredProtectedLane(probe)) hold = { pause_reason: 'protected-lane-declared', lane: 'declared' };
+  else {
+    const sniffed = sniffedProtectedLane(probe);
+    if (sniffed) hold = { pause_reason: `protected-lane-${sniffed.lane}`, lane: sniffed.lane };
+  }
+  // Inside a campaign, a person may have allowed this lane by answering the
+  // campaign's ask. Only a person's answer closes an ask, so it counts as the ack.
+  if (hold && mission?.campaign_id && campaignApprovedLane(root, mission.campaign_id, hold.lane)) return null;
+  return hold ? { pause_reason: hold.pause_reason } : null;
+}
+
+function campaignApprovedLane(root, campaignId, lane) {
+  try {
+    const { openCampaignStore } = require('../lib/campaign-store');
+    const { approvedLanes } = require('../lib/campaign-lanes');
+    return approvedLanes(openCampaignStore(root).read(campaignId)).has(lane);
+  } catch {
+    return false;
+  }
 }
 
 function runnerUsesCallerSession(runner) {
@@ -10342,7 +10358,7 @@ async function executeMissionRunTicksPhase(context) {
       if (['complete', 'stopped', 'paused'].includes(mission.status)) { pauseReason = mission.status; break; }
       if (effectiveMissionVerifier(mission) !== storedVerifier) { pauseReason = 'verifier-mutated'; break; }
       if ((mission.lane || 'workspace') !== frozen.lane) { pauseReason = 'lane-mutated'; break; }
-      const protectedHold = missionProtectedLaneHold(mission);
+      const protectedHold = missionProtectedLaneHold(mission, cwd);
       if (protectedHold) { pauseReason = protectedHold.pause_reason; break; }
 
       const tickIdx = Number(mission.last_tick_index || 0) + 1;

package/lib/campaign-cadence.js

@@ -9,6 +9,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { paysDollars } = require('./campaign-core');
 const { getCampaign, openCampaignStore } = require('./campaign-store');
 
 const LESSON_LINES_FOR_PLANNING = 30;
@@ -44,8 +45,14 @@ function roundSummary(before, after) {
   return { kept, failed, vetoed, spent, fresh };
 }
 
+// On a subscription the round is told without dollars, since none were paid.
+function roundTally(view, summary) {
+  return `${summary.kept} kept, ${summary.failed} failed${paysDollars(view) ? `, $${summary.spent} spent` : ''}`;
+}
+
 function reviewPrompt(view, summary, lessons) {
-  const missions = summary.fresh.map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${m.cost_usd !== null ? `, $${m.cost_usd}` : ''}`).join('\n') || '- none ended this round';
+  const paid = paysDollars(view);
+  const missions = summary.fresh.map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${paid && m.cost_usd !== null ? `, $${m.cost_usd}` : ''}`).join('\n') || '- none ended this round';
   return [
     'You review one round of an Atris campaign. Reply with 2 to 6 short lessons, one per line, each starting with "- ".',
     'A lesson says what to do differently next round, in plain words. Do not repeat a lesson already listed.',
@@ -53,7 +60,7 @@ function reviewPrompt(view, summary, lessons) {
     `Campaign: ${view.title}`,
     `Judge: ${view.judge}`,
     `Judge now: ${view.last_judge ? `${view.last_judge.passed ? 'passed' : 'failed'}${view.last_judge.reading !== null ? ` (reading ${view.last_judge.reading})` : ''}: ${view.answer.text || ''}` : 'never run'}`,
-    `This round: ${summary.kept} kept, ${summary.failed} failed, ${summary.vetoed} could not start, $${summary.spent} spent`,
+    `This round: ${summary.kept} kept, ${summary.failed} failed, ${summary.vetoed} could not start${paid ? `, $${summary.spent} spent` : ''}`,
     'Missions this round:',
     missions,
     '',
@@ -88,9 +95,9 @@ function makeCadence(root, loop, options = {}, deps = {}) {
     fs.mkdirSync(path.dirname(file), { recursive: true });
     if (!fs.existsSync(file)) fs.writeFileSync(file, `# Lessons: ${after.title}\n\nWritten by the owner at each review; the next round plans from them.\n`);
     const stamp = new Date(now()).toISOString().slice(0, 16).replace('T', ' ');
-    const header = `\n## ${stamp}: ${summary.kept} kept, ${summary.failed} failed, $${summary.spent} spent\n`;
+    const header = `\n## ${stamp}: ${roundTally(after, summary)}\n`;
     fs.appendFileSync(file, `${header}${(written.length ? written : ['- (no review written this round)']).join('\n')}\n`);
-    return { summary, lessons: written };
+    return { summary, lessons: written, view: after };
   }
 
   async function run(id) {
@@ -111,8 +118,8 @@ function makeCadence(root, loop, options = {}, deps = {}) {
       }
       const breakStarted = now();
       log(`round ${round}: review`);
-      const { summary, lessons } = await review(id, before);
-      log(`  ${summary.kept} kept, ${summary.failed} failed, $${summary.spent} spent; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
+      const { summary, lessons, view: reviewed } = await review(id, before);
+      log(`  ${roundTally(reviewed, summary)}; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
       const view = getCampaign(store, id);
       last = { reason: stopped || 'work window ended', round };
       // Finished, out of money, or waiting on a person: no point in another round.

package/lib/campaign-core.js

@@ -282,6 +282,9 @@ function fold(events) {
     bet: s.bet,
     parent: s.parent,
     home: s.home,
+    // Only when the start event names one, so the shared golden views stay as
+    // pinned; no basis means the person's own engines.
+    ...(d.basis === 'atris_cloud' || d.basis === 'own_engines' ? { basis: d.basis } : {}),
     created_from: d.created_from === undefined ? null : d.created_from,
     seats: s.seats,
     state,
@@ -327,4 +330,12 @@ function decide(view) {
   return { action: 'propose', reason: 'no missions queued' };
 }
 
-module.exports = { cents, compareEvents, decide, fold };
+// Spend is real dollars only when billing is API or Atris runs the campaign on
+// its own engines (basis atris_cloud). Otherwise the work ran on the person's own
+// subscriptions: they paid nothing, and cost_usd stays as the API-price budget meter.
+function paysDollars(view) {
+  if (process.env.ATRIS_BILLING === 'api') return true;
+  return Boolean(view && view.basis === 'atris_cloud');
+}
+
+module.exports = { cents, compareEvents, decide, fold, paysDollars };

package/lib/campaign-lanes.js

@@ -0,0 +1,52 @@
+'use strict';
+
+// Protected lanes inside a campaign. A mission that touches billing, security,
+// deploys, or customers pauses before its first tick (missionProtectedLaneHold).
+// Inside a campaign that pause becomes an ask; a person answering yes approves
+// that one lane for that one campaign. The approval lives in the campaign's own
+// event log, where only a person's answer closes an ask.
+
+const { isHumanActor } = require('./campaign-schema');
+
+const LANE_ASK_KIND = 'protected_lane';
+const YES = /^\s*(y|yes|ok|okay|approve|approved|allow|go|sure)\b/i;
+const PAUSE_LINE = /paused: protected-lane-([a-z]+)/i;
+
+// The lane a paused `atris mission run` reported, or null.
+function pausedLane(output) {
+  const match = String(output || '').match(PAUSE_LINE);
+  return match ? match[1].toLowerCase() : null;
+}
+
+// Lanes a person approved, from a campaign's events.
+function approvedLanes(events) {
+  const asked = new Map();
+  const lanes = new Set();
+  for (const event of events || []) {
+    const data = event && event.data ? event.data : {};
+    if (event.type === 'ask_opened' && data.kind === LANE_ASK_KIND && data.lane) asked.set(data.ask_id, data.lane);
+    if (event.type === 'ask_answered' && asked.has(data.ask_id) && isHumanActor(event.actor) && YES.test(String(data.answer || ''))) {
+      lanes.add(asked.get(data.ask_id));
+    }
+  }
+  return lanes;
+}
+
+// True when this campaign already has an open ask for the lane, so the loop asks once.
+function laneAskOpen(events, lane) {
+  const open = new Set();
+  for (const event of events || []) {
+    const data = event && event.data ? event.data : {};
+    if (event.type === 'ask_opened' && data.kind === LANE_ASK_KIND && data.lane === lane) open.add(data.ask_id);
+    if (event.type === 'ask_answered') open.delete(data.ask_id);
+  }
+  return open.size > 0;
+}
+
+function laneQuestion(lane, member, objective) {
+  const what = String(objective || '').replace(/\s+/g, ' ').trim();
+  const short = what.length > 140 ? `${what.slice(0, 139)}…` : what;
+  return `${member}'s mission touches ${lane}: "${short}". Missions that touch ${lane} wait for you. Let this campaign work on ${lane}? Answer yes to allow it.`;
+}
+
+module.exports = { LANE_ASK_KIND, pausedLane, approvedLanes, laneAskOpen, laneQuestion };

package/lib/campaign-loop.js

@@ -12,6 +12,7 @@ const { decide } = require('./campaign-core');
 const { getCampaign, openCampaignStore } = require('./campaign-store');
 const { defaultReserve, reconcileCampaign } = require('./campaign-missions');
 const { judgeRanData, latestJudgeOutput } = require('./campaign-reading');
+const { LANE_ASK_KIND, pausedLane, laneAskOpen, laneQuestion } = require('./campaign-lanes');
 
 const TERMINAL = new Set(['stopped', 'complete']);
 
@@ -86,17 +87,37 @@ async function askOwner(root, view, prompt) {
 }
 
 // Run one atris command and resolve with its exit code and output.
+// A live step an engine prints while a mission runs: "<member> <hh:mm>  <what it is doing>".
+const ACTIVITY_LINE = /^\s*[a-z0-9][a-z0-9-]*\s+\d{1,2}:\d{2}\s{2,}\S/i;
+
 function runCli(args, { cwd, env = process.env, onLine = null } = {}) {
   return new Promise((resolve) => {
     const child = spawn(process.execPath, [CLI, ...args], { cwd, env: { ...env, ATRIS_SKIP_UPDATE_CHECK: '1' }, stdio: ['ignore', 'pipe', 'pipe'] });
     let out = '';
     let err = '';
-    child.stdout.on('data', (chunk) => {
-      out += chunk;
-      if (onLine) String(chunk).split('\n').filter(Boolean).forEach(onLine);
+    // Whole lines only: a chunk can end mid-line. Live engine steps arrive on
+    // stderr (member-progress reportProgress), so both streams are read.
+    const reader = () => {
+      let partial = '';
+      return {
+        push(chunk) {
+          if (!onLine) return;
+          const lines = (partial + String(chunk)).split('\n');
+          partial = lines.pop();
+          lines.filter(Boolean).forEach(onLine);
+        },
+        end() { if (onLine && partial) onLine(partial); },
+      };
+    };
+    const stdout = reader();
+    const stderr = reader();
+    child.stdout.on('data', (chunk) => { out += chunk; stdout.push(chunk); });
+    child.stderr.on('data', (chunk) => { err += chunk; stderr.push(chunk); });
+    child.on('close', (code) => {
+      stdout.end();
+      stderr.end();
+      resolve({ code, out, err });
     });
-    child.stderr.on('data', (chunk) => { err += chunk; });
-    child.on('close', (code) => resolve({ code, out, err }));
   });
 }
 
@@ -111,7 +132,7 @@ function makeLoop(root, options = {}, deps = {}) {
   const runner = options.runner || 'auto';
   const actor = options.actor || 'mission-lead';
   const ask = deps.ask || askOwner;
-  const cli = deps.cli || ((args) => runCli(args, { cwd: root }));
+  const cli = deps.cli || ((args, extra = {}) => runCli(args, { cwd: root, ...extra }));
   const judge = deps.judge;
 
   const view = (id) => getCampaign(store, id);
@@ -168,8 +189,22 @@ function makeLoop(root, options = {}, deps = {}) {
       return { mission_id: work.mission_id, started: false };
     }
     log(`  ${work.mission_id} started for ${work.member}: ${work.objective}`);
-    const ran = await cli(['mission', 'run', work.mission_id, '--max-ticks', String(maxTicks), '--complete-on-pass']);
+    // The engine's live steps ("researcher 06:47  editing stable.mjs") pass through to
+    // the campaign's own output, so a screen watching the run can show the work.
+    const ran = await cli(['mission', 'run', work.mission_id, '--max-ticks', String(maxTicks), '--complete-on-pass'], { onLine: (line) => { if (ACTIVITY_LINE.test(line)) log(`    ${line.trim()}`); } });
     const after = view(id).missions.find((m) => m.id === work.mission_id);
+    // A mission in a protected lane (billing, security, deploy, customer) pauses
+    // before its first tick. Ask a person once per lane instead of failing quietly.
+    const lane = after && after.status !== 'ended' ? pausedLane(`${ran.out || ''}\n${ran.err || ''}`) : null;
+    if (lane) {
+      if (!laneAskOpen(store.read(id), lane)) {
+        const askId = `a-${crypto.randomBytes(3).toString('hex')}`;
+        append(id, 'ask_opened', { ask_id: askId, question: laneQuestion(lane, work.member, work.objective), mission_id: work.mission_id, kind: LANE_ASK_KIND, lane }, current.owner);
+      }
+      await cli(['mission', 'stop', work.mission_id, '--reason', `campaign loop: waiting for a person to allow the ${lane} lane`]);
+      log(`  ${work.mission_id} needs you: it touches ${lane}`);
+      return { mission_id: work.mission_id, started: true, outcome: null, needs: lane };
+    }
     if (after && after.status !== 'ended') {
       // The run stopped without finishing (tick cap, error): close it so its
       // reserve comes back and its cost is counted.
@@ -243,4 +278,4 @@ function makeLoop(root, options = {}, deps = {}) {
   return { step, run, propose };
 }
 
-module.exports = { askOwner, makeLoop, parseProposals, proposalPrompt };
+module.exports = { ACTIVITY_LINE, askOwner, makeLoop, parseProposals, proposalPrompt, runCli };

package/lib/campaign-protect.js

@@ -29,6 +29,12 @@ function protectFile(home, campaignId) {
   return path.join(home, 'campaigns', campaignId, 'protect.json');
 }
 
+// The commit a checkout sits on, or null outside git or before the first commit.
+function headCommit(root) {
+  const head = git(root, ['rev-parse', 'HEAD']);
+  return head.ok ? head.out : null;
+}
+
 // The commit and checkout-relative paths to save, or an error in plain words.
 function planProtect(root, paths) {
   const topDir = checkoutTop(root);
@@ -72,4 +78,4 @@ function changedProtected(root, saved) {
   return { changed: [...new Set(changed)].sort() };
 }
 
-module.exports = { campaignHome, changedProtected, checkoutTop, planProtect, protectFile, readProtect, saveProtect };
+module.exports = { campaignHome, changedProtected, checkoutTop, headCommit, planProtect, protectFile, readProtect, saveProtect };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.71.1",
+  "version": "3.71.2",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {