cawdev-cli 1.0.5-beta → 1.0.7-beta

package/runner/runner.mjs

@@ -40,13 +40,18 @@ import {
 } from '../lib/stage-tools.mjs';
 import { capabilityIn, describeCall } from '../lib/tool-line.mjs';
 import { findSecret } from '../lib/secrets.mjs';
+import { BackgroundShells } from '../lib/background-shells.mjs';
 import { cliVersion, isBelow } from '../lib/version.mjs';
 import { reloadableFor, restartNeededFor } from '../lib/runner-config.mjs';
 import {
   createAutoWorkspace, discoverAutoWorkspaces, isAutoWorkspace,
 } from './auto-workspaces.mjs';
-import { agentOfCommand } from '../lib/agents.mjs';
+import { agentOfCommand, needsEverything } from '../lib/agents.mjs';
 import { cawdevToolNames, codexArgs, translateCodexEvent } from '../lib/codex.mjs';
+import {
+  drivingPath, isAlive, killedByRestart, leftBehind, memoryMaxOf, probeScope, readDriving,
+  restartSummary, scoped, snapshotOf, writeDriving,
+} from './restart.mjs';
 
 // --- configuration -----------------------------------------------------------
 
@@ -419,6 +424,12 @@ async function readConfig() {
      * switched on, never on by default.
      */
     autoWorkspaces: autoWorkspacesOf(file.autoWorkspaces),
+    /**
+     * R339: the memory ceiling each agent session is spawned under, as
+     * systemd reads it (`6G`, `75%`) — Linux only, see restart.mjs. Absent is
+     * none. Raw here; `main` probes whether this machine can apply it.
+     */
+    sessionMemoryMax: file.sessionMemoryMax ?? null,
     skillCache: file.skillCache ?? DEFAULTS.skillCache,
     skillPrepareSeconds: file.skillPrepareSeconds ?? DEFAULTS.skillPrepareSeconds,
     idleSeconds: file.idleSeconds ?? DEFAULTS.idleSeconds,
@@ -5182,21 +5193,60 @@ function argsForProfile(agentArgs, profile, run, expertAgents = [], skills = [])
  * re-derived the plan from a précis would be planning again, which is the one
  * thing the gate exists to stop it doing after somebody approved the first one.
  */
-function stagePrompt(stage, carried) {
+/** Longer than ask_user's own ten-minute wait — see the cawdev server of spawnCodex. */
+const CAWDEV_TOOL_TIMEOUT_SEC = 660;
+
+/**
+ * A decision that is the person's is ASKED, and the stage goes on with the
+ * answer. R19 and R24 (Codex) each met one — a plan the code had moved away
+ * from, a plan whose review left the scope open — and ended the stage saying
+ * so, the run FINISHED with nothing built and the question in a summary
+ * nobody was asked. Claude asked; the wording let Codex stop instead.
+ */
+const ASK_DONT_STOP = 'If a decision is genuinely the person\'s — a scope the card leaves open, '
+  + 'a plan that no longer matches the code, a trade-off with no right answer — ASK it with '
+  + '`ask_user` (a round of questions if there are several), wait for the answer, and carry on '
+  + 'with it. Never end this stage on an open question: a question left in your report is one '
+  + 'nobody was asked.';
+
+/**
+ * A stage is ONE turn, and it ends the moment the turn does — so a command left
+ * running in the background is a result lost (background-shells.mjs).
+ */
+const WAIT_FOR_COMMANDS = 'This stage ends when your turn ends: run every command in the '
+  + 'foreground and wait for it to finish — a build or a test suite left running in the '
+  + 'background is lost, and the stage is run again.';
+
+/**
+ * @param hasPlan whether the card has a plan of record — the same test
+ *   harnessPrompt uses to draw "The plan for this card" (`plan?.body`), so the
+ *   instruction and the block it points at cannot disagree
+ */
+function stagePrompt(stage, carried, hasPlan = true) {
   const asked = {
     PLAN: 'Work out what to do and WRITE THE PLAN. Do not change anything — you have no '
       + 'tool that can, so do not spend turns discovering that. Read what you need, then say, '
       + 'concretely: which files, what change in each, and how you will know it worked. '
       + 'What you report becomes the card\'s plan, and a DIFFERENT session — another '
       + 'process, with none of your context — will be handed it and told to carry it out. '
-      + 'Write it for them.',
+      + 'Write it for them — with every decision in it already made. ' + ASK_DONT_STOP,
     VERIFY: 'Check the plan against what is actually there. Does every file it names exist? '
       + 'Does every interface it assumes still look like that? You cannot change anything — '
       + 'say what is wrong with the plan, or say plainly that it holds.',
-    IMPLEMENT: 'Do the work in the plan — it is under "The plan for this card" above, '
-      + 'written by the plan phase and agreed. If it turns out to be wrong, say so and stop '
-      + 'rather than improvising a different change: somebody approved that plan, and a '
-      + 'different one has not been approved.',
+    // With a plan, the plan is the task. Without one — `/new dev R21` on a
+    // card nobody planned — the CARD is: the old wording pointed at a plan
+    // section that was not there, and a careful session read "stop rather than
+    // improvise" as "stop", ending R21 with nothing built and nothing to push.
+    IMPLEMENT: (hasPlan
+      ? 'Do the work in the plan — it is under "The plan for this card" above, '
+        + 'written by the plan phase and agreed. Do not quietly improvise a different change: '
+        + 'somebody approved that plan. If it turns out to be wrong or incomplete, ask what to '
+        + 'do instead of stopping — and stop only if the answer is to stop. '
+      : 'This card has no plan, and it does not need one: it was started straight into '
+        + 'development, so the CARD\'s text is the task. Work out what it asks — read the code '
+        + 'it touches first — build it, and commit it on this branch. Never stop because a plan '
+        + 'is missing. ')
+      + ASK_DONT_STOP + ' ' + WAIT_FOR_COMMANDS,
     // R129. Two honest ways to do this stage, and the project chose one. The
     // TESTBOOK wording says "you have no tool that could" for the PLAN
     // prompt's reason: a session that has to discover a refusal spends turns
@@ -5215,7 +5265,8 @@ function stagePrompt(stage, carried) {
         + 'failing test is a result, not a failure of this stage. The branch\'s SonarQube gate '
         + 'is one call away — `quality_get`, which reads this run\'s branch by default; a red '
         + 'gate with new vulnerabilities is a finding to report with the output, not a failure '
-        + 'to hide.',
+        + 'to hide. ' + WAIT_FOR_COMMANDS + ' Then commit the branch\'s changes — no stage '
+        + 'after this one writes code, and work left uncommitted is work nothing can push.',
     MEMORY: 'Write what the NEXT session on this branch needs to know: what was done, what was '
       + 'tried and rejected and why, and anything that turned out to matter and would not be '
       + 'obvious from the diff. Be brief and concrete. This is saved as this branch\'s '
@@ -6556,8 +6607,23 @@ async function walkLifecycle(config, run, runToken, cwd, baseCommit, workspace,
     return { tokensIn: Number(row?.tokensIn) || 0, tokensOut: Number(row?.tokensOut) || 0 };
   };
 
+  const storedRow = (name) => (Array.isArray(stored)
+    ? stored.find((each) => each?.stage === name) : null);
+
   for (let at = 0; at < lifecycle.length; at++) {
     const stage = lifecycle[at];
+    // Where a carried-on run resumes, and what its DONE stages said, is the
+    // platform's (R263, `WorkflowService.resumeFrom`): the claim's lifecycle
+    // starts at the first stage not DONE. What only the daemon knows is WHY
+    // the stage about to run stopped last time — so that is handed to it.
+    const before = storedRow(stage.stage);
+    if (before?.state === 'FAILED' && before.outcome) {
+      // The attempt that stopped, handed to the one about to run.
+      carried[`${stage.stage} (the attempt that stopped)`] = `${before.outcome}\n\n`
+        + 'This stage is being run again to finish that. Run the commands it left running '
+        + 'again IN THE FOREGROUND — not with run_in_background — wait for each one to end '
+        + 'and read its output, then finish the stage properly.';
+    }
     // R305. What THIS stage's processes have used, across its attempts. Outside
     // the attempt loop on purpose: `run_stage` is one row per stage and keeps
     // the larger reading, so a second attempt after a refused gate must report
@@ -6668,6 +6734,21 @@ async function walkLifecycle(config, run, runToken, cwd, baseCommit, workspace,
         return;
       }
 
+      // The turn ended, but with commands it started in the background still
+      // running, or finished and never read. Not done: the result is what the
+      // stage was for. FAILED keeps the checkout and the session (R80), so
+      // /continue picks the run up HERE — the stages behind it stay pending.
+      if (last?.unfinishedShells?.length) {
+        const listed = last.unfinishedShells.map((command) => `\`${command.slice(0, 120)}\``).join(', ');
+        const why = `The ${stage.stage} stage ended with ${last.unfinishedShells.length} command(s) `
+          + `still running in the background, or finished and never read: ${listed}. `
+          + 'Nothing they proved was recorded — /continue runs this stage again and waits for them.';
+        log(`  ${why}`);
+        await reportStage(config, run, stage.stage, 'report', { state: 'FAILED', outcome: why });
+        await finish(config, run, 'FAILED', `${why}\n\n${last.text ?? ''}`.trim());
+        return;
+      }
+
       await reportStage(config, run, stage.stage, 'report', {
         state: 'DONE',
         // The PLAN's text IS the plan — the artefact R109 exists to store, and
@@ -6684,6 +6765,15 @@ async function walkLifecycle(config, run, runToken, cwd, baseCommit, workspace,
       if (decision.allowed) {
         break;
       }
+      if (decision.expired) {
+        // R339. Unread is not refused: re-running the stage would spend a
+        // second stage on a plan nobody has looked at yet.
+        const why = `Stopped at the ${stage.stage} gate: ${decision.reason}. Nothing was `
+          + 'refused — start the run again when somebody can read it.';
+        await skipRest(config, run, lifecycle, at + 1, why);
+        await finish(config, run, 'FINISHED', why);
+        return;
+      }
       if (attempt === 1) {
         const why = `Stopped at the ${stage.stage} gate: ${decision.reason ?? 'refused twice.'}`;
         // The same trail R122 came from: a run that ends here never reaches the
@@ -6787,6 +6877,11 @@ async function awaitGate(config, run, runToken, stage, text) {
   }
 
   log(`  waiting at the ${stage.stage} gate`);
+  // R339: no deadline of its own by default. A gate is a person reading the
+  // plan, the platform never expires one, and a run waiting on it is never
+  // swept — a timer here turned "not read yet" into a refusal and re-ran the
+  // stage, which is spend nobody asked for. An older platform that does
+  // expire it still answers EXPIRED, which is handled below.
   const deadline = Date.now() + gateTimeoutSeconds() * 1000;
   while (Date.now() < deadline) {
     const remaining = Math.ceil((deadline - Date.now()) / 1000);
@@ -6798,6 +6893,12 @@ async function awaitGate(config, run, runToken, stage, text) {
       // the transport — a 204 and a `{state: 'PENDING'}` both mean "not yet",
       // and depending on which one the platform chose would be depending on
       // something nobody promised.
+      if (decision?.state === 'EXPIRED') {
+        // A platform from before R339. Nobody said no, so this is not a
+        // refusal to re-run the stage over: the run stops at the gate.
+        log(`  the ${stage.stage} gate expired unread`);
+        return { allowed: false, expired: true, reason: 'nobody read it in time' };
+      }
       if (decision && decision.state && decision.state !== 'PENDING') {
         const allowed = decision.state === 'ALLOWED';
         log(`  the ${stage.stage} gate was ${allowed ? 'allowed' : 'refused'}`);
@@ -6808,13 +6909,29 @@ async function awaitGate(config, run, runToken, stage, text) {
       return { allowed: false, reason: `waiting failed (${failure.message})` };
     }
   }
-  return { allowed: false, reason: 'nobody answered in time' };
+  return { allowed: false, expired: true, reason: 'nobody answered in time' };
 }
 
-/** A little past the platform's own expiry, like the MCP server's. */
+/**
+ * How long a gate waits before the daemon gives up on it: for ever, unless a
+ * test says otherwise — R339. The platform decides when nobody is coming.
+ */
 function gateTimeoutSeconds() {
   const configured = Number(process.env.CAWDEV_GATE_TIMEOUT_SECONDS);
-  return Number.isFinite(configured) && configured > 0 ? configured : 960;
+  return Number.isFinite(configured) && configured > 0 ? configured : Infinity;
+}
+
+/**
+ * An agent session, spawned under the machine's memory ceiling when it has
+ * one — R339. `systemd-run --scope` execs in place, so the pid, the group and
+ * the pipes are the agent's own. `cawdevCommand` is what the next daemon reads
+ * off the driving note to tell this session's orphan from a reused pid.
+ */
+function spawnScoped(config, command, args, options) {
+  const line = scoped(command, args, config.sessionScope);
+  const child = spawn(line.command, line.args, options);
+  child.cawdevCommand = command;
+  return child;
 }
 
 async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, resume,
@@ -7235,7 +7352,7 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
   log(`  spawning: ${agentCmd} ${args.join(' ')} (prompt on stdin)`);
 
   return new Promise((resolvePromise) => {
-    const child = spawn(agentCmd, args, {
+    const child = spawnScoped(config, agentCmd, args, {
       cwd,
       // Its own process group, so cancelling can take down the whole tree
       // rather than leaving orphaned children behind.
@@ -7300,7 +7417,7 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
     // sending it again is a repeat wearing a resume's clothes — R69's rule about
     // the opening prompt, applied to the thing that now travels with it.
     writeUserMessage(child, resume?.prompt
-      ?? (promptFor(run) + harness + (stage ? stagePrompt(stage, carried) : '')));
+      ?? (promptFor(run) + harness + (stage ? stagePrompt(stage, carried, Boolean(plan?.body)) : '')));
 
     let lastText = '';
     // R305. This child's own last reading, handed back to the walk so the next
@@ -7326,6 +7443,10 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
     // wait for it, which is exactly the shape that loses it when `endSession`
     // closes stdin below.
     const backgrounded = new Set();
+    // Shell commands this child started in the background and never saw end
+    // — the walk will not call a stage done with any of them left (see
+    // background-shells.mjs).
+    const shells = new BackgroundShells();
     // The last of what the CLI said on stderr, for the exit decision below.
     // The usage-limit notice is written there, and a decision made on stdout
     // alone would call every window a crash.
@@ -7487,6 +7608,7 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
         buffer = buffer.slice(newline + 1);
         if (!line) continue;
         const event = safeJson(line);
+        if (event) shells.observe(event);
 
         // i257. Read off the RAW event, before `linesOf` flattens it to a
         // string: `describeCall` (`../lib/tool-line.mjs`) never carries
@@ -7893,7 +8015,8 @@ async function spawnAgent(config, run, runToken, cwd, baseCommit, workspace, res
       // gate on it, and carry it into the next stage. A run with no lifecycle
       // resolves with nothing, exactly as it always did.
       resolvePromise(stage
-        ? { code, signal, text: lastText, turnEnded, usage: childTotals }
+        ? { code, signal, text: lastText, turnEnded, usage: childTotals,
+          unfinishedShells: shells.unfinished() }
         : undefined);
     });
   });
@@ -8188,14 +8311,36 @@ function inlinedSkillsFor(skills) {
  * tool a session delegates through — confirmed end-to-end by hand, a probe
  * agent installed, invoked by name, and its answer returned correctly.
  */
+/** This machine, as a refusal names it: what it is called, where its config and console are. */
+function thisMachine(config) {
+  return {
+    name: config.name,
+    acceptsConsoleRules: config.acceptsRulesFromConsole === true,
+    configPath: config.configPath ?? null,
+    consoleUrl: config.url,
+  };
+}
+
+/**
+ * A refusal said on the run's own transcript, where the terminal and the run
+ * page show it — the run's summary alone left a window reading "failed" and
+ * nothing else, with the reason one page away.
+ */
+async function sayOnTheRun(config, run, text) {
+  await api(config, `/api/projects/${run.projectSlug}/runs/${run.id}/output`, {
+    method: 'POST',
+    body: { lines: text.split('\n').filter((body) => body.trim()).map((body) => ({ kind: 'ERROR', body })) },
+  }).catch((failure) => log(`  could not say it on the run: ${failure.message}`));
+}
+
 async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume, projectServers,
     skills, stageExperts, cannotDelegate, instincts, briefing, plan, lifecycle, stage, carried,
     agyCmd, granted, usage = null) {
   if (!granted.everything) {
-    const summary = 'This machine has not allowed everything, and Antigravity has no narrower '
-      + 'permission mode — no per-tool allow-list exists on it, and even reading needs it. Turn '
-      + 'on "allow everything" for this machine, or use Claude Code for this run.';
-    log(`  refusing to spawn Antigravity: ${summary}`);
+    // Antigravity needs it even to read: no per-tool allow-list exists on it.
+    const summary = needsEverything('agy', thisMachine(config), run, { readsWithout: false });
+    log(`  refusing to spawn Antigravity: ${summary.split('\n')[0]}`);
+    await sayOnTheRun(config, run, summary);
     await finish(config, run, 'FAILED', summary);
     return stage ? { code: -1, signal: null, text: summary, turnEnded: false } : undefined;
   }
@@ -8285,7 +8430,7 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
   const promptText = resuming
     ? resume.prompt
     : (promptFor(run) + harness + skillsBlock + expertsBlock
-      + (stage ? stagePrompt(stage, carried) : ''));
+      + (stage ? stagePrompt(stage, carried, Boolean(plan?.body)) : ''));
 
   const args = ['-p', promptText, '--output-format', 'stream-json', '--dangerously-skip-permissions'];
   if (run.model) {
@@ -8319,7 +8464,7 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
     let childTotals = null;
     let err = '';
     let buffer = '';
-    const child = spawn(agyCmd, args, {
+    const child = spawnScoped(config, agyCmd, args, {
       cwd,
       // Its own process group — see the same choice on the Claude Code path.
       detached: true,
@@ -8334,6 +8479,12 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
     // Code one does, with no code of its own.
     running.set(run.id, child);
 
+    // What the console can see of the checkout, and the commits as they land —
+    // the same watcher as the Claude Code path. Without it the platform never
+    // hears of this run's commits, so the finish rules (R40) see a run that
+    // wrote nothing and queue no push and no pull request.
+    const workingCopy = watchWorkingCopy(config, run, cwd, baseCommit);
+
     // stream-json arrives in chunks that split mid-line, same as Claude
     // Code's — buffer until a full line rather than assuming one chunk is
     // one event.
@@ -8430,6 +8581,7 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
     });
 
     child.on('error', async (failure) => {
+      workingCopy.stop();
       running.delete(run.id);
       const summary = `Could not spawn Antigravity: ${failure.message}`;
       await transcript.flush();
@@ -8439,6 +8591,7 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
     });
 
     child.on('close', async (code) => {
+      workingCopy.stop();
       running.delete(run.id);
       await transcript.flush();
       const text = result?.response
@@ -8466,6 +8619,10 @@ async function spawnAntigravity(config, run, runToken, cwd, baseCommit, resume,
       if (!stage) {
         await settleActions(config, run, cwd);
       }
+      // The last reading, as on the Claude Code path: after the agent has
+      // stopped and after anything the rules did.
+      await reportCommits(config, run, cwd, baseCommit);
+
       resolvePromise(stage
         ? { code, signal: null, text, turnEnded, usage: childTotals }
         : undefined);
@@ -8535,17 +8692,18 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     skills, stageExperts, readOnlyStage, instincts, briefing, plan, lifecycle, stage, carried,
     codexCmd, granted, shield, usage = null) {
   const failedBeforeSpawn = async (summary) => {
-    log(`  ${summary}`);
+    log(`  ${summary.split('\n')[0]}`);
+    await sayOnTheRun(config, run, summary);
     await finish(config, run, 'FAILED', summary);
     return stage ? { code: -1, signal: null, text: summary, turnEnded: false } : undefined;
   };
 
   const mayWrite = writesCodeProfile(run) && !readOnlyStage;
   if (mayWrite && !granted.everything) {
-    return failedBeforeSpawn('This machine has not allowed everything, and a Codex session that '
-      + 'writes has no narrower mode — it must commit and push, which its sandbox refuses, and '
-      + 'there is no allow-list for its shell. Turn on "allow everything" for this machine, or use '
-      + 'Claude Code for this run. (Read-only runs and stages need nothing.)');
+    // It must commit and push, which its sandbox refuses, and there is no
+    // allow-list for its shell — so everything, or nothing. Read-only runs
+    // and stages need nothing.
+    return failedBeforeSpawn(needsEverything('codex', thisMachine(config), run));
   }
   if (mayWrite) {
     log('  !! this machine allows EVERYTHING: this Codex session runs without a sandbox');
@@ -8591,6 +8749,12 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     args: [serverPath],
     envVars: Object.keys(cawdevEnv),
     enabledTools: codexCawdevTools(run, stage, mayWrite),
+    // Codex cuts an MCP call off after 60 s unless told otherwise, and
+    // `ask_user` waits up to ten minutes for a person: a question asked from
+    // Codex died before anybody could answer it, so it did not ask — it
+    // stopped. Longer than ask_user's own wait (mcp/server.mjs), so the
+    // question is answered or handed back as pending, never cut off.
+    toolTimeoutSec: CAWDEV_TOOL_TIMEOUT_SEC,
   });
 
   const cannotDelegate = stageExperts.length
@@ -8612,7 +8776,7 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
       })
       + inlinedSkillsFor(skills)
       + expertsBlockFor([], cannotDelegate)
-      + (stage ? stagePrompt(stage, carried) : ''));
+      + (stage ? stagePrompt(stage, carried, Boolean(plan?.body)) : ''));
 
   const model = stage?.model ?? run.model;
   const args = codexArgs({
@@ -8639,7 +8803,7 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     let lastSaid = null;
     let err = '';
     let buffer = '';
-    const child = spawn(codexCmd, args, {
+    const child = spawnScoped(config, codexCmd, args, {
       cwd,
       // Its own process group — see the same choice on the Claude Code path.
       detached: true,
@@ -8651,6 +8815,13 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     child.cawdevModel = model ?? null;
     // `reapCancelled` SIGTERMs whatever is here, whichever CLI it is.
     running.set(run.id, child);
+
+    // What the console can see of the checkout, and the commits as they land —
+    // the same watcher as the Claude Code path. Without it the platform never
+    // hears of this run's commits, so the finish rules (R40) see a run that
+    // wrote nothing and queue no push and no pull request.
+    const workingCopy = watchWorkingCopy(config, run, cwd, baseCommit);
+
     child.stdin.on('error', () => {
       // A CLI that died before reading its prompt says why on stderr.
     });
@@ -8728,6 +8899,7 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     });
 
     child.on('error', async (failure) => {
+      workingCopy.stop();
       running.delete(run.id);
       const summary = `Could not spawn Codex: ${failure.message}`;
       await transcript.flush();
@@ -8736,6 +8908,7 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
     });
 
     child.on('close', async (code) => {
+      workingCopy.stop();
       running.delete(run.id);
       await transcript.flush();
       const text = failed ?? lastSaid ?? lastError ?? (err.trim() || 'Codex produced no output.');
@@ -8750,6 +8923,10 @@ async function spawnCodex(config, run, runToken, cwd, baseCommit, resume, projec
       if (!stage) {
         await settleActions(config, run, cwd);
       }
+      // The last reading, as on the Claude Code path: after the agent has
+      // stopped and after anything the rules did.
+      await reportCommits(config, run, cwd, baseCommit);
+
       resolvePromise(stage
         ? { code, signal: null, text, turnEnded: ended && !failed, usage: childTotals }
         : undefined);
@@ -8808,6 +8985,101 @@ async function finish(config, run, state, summary) {
 
 // --- cancellation ------------------------------------------------------------
 
+/**
+ * What the daemon before this one was driving when it died — R339.
+ *
+ * Read off the note it kept (restart.mjs), and only when its writer is dead:
+ * a live writer is a second daemon on this runner id. Each run the platform
+ * still believes in is failed at once as DAEMON_RESTARTED, in words that name
+ * the cause — where the stale sweep would have said, five minutes later, that
+ * the runner "stopped driving it". A session the old daemon left running
+ * unattended is stopped first: two sessions writing one checkout is worse
+ * than either.
+ */
+async function reportWhatARestartKilled(config) {
+  const path = drivingPath(config.runnerId);
+  const previous = await readDriving(path);
+  const behind = leftBehind(previous, process.pid, isAlive);
+  for (const left of behind) {
+    const run = await api(config, `/api/projects/${left.projectSlug}/runs/${left.id}`)
+      .catch((failure) => {
+        log(`could not read ${left.id} after the restart: ${failure.message}`);
+        return null;
+      });
+    if (!killedByRestart(run, config.runnerId)) {
+      continue;
+    }
+    const orphanStopped = await stopOrphan(left);
+    log(`run ${left.id} was being driven when this daemon last died (pid ${previous.pid}); `
+      + 'reporting it');
+    await api(config, `/api/projects/${left.projectSlug}/runs/${left.id}/transition`, {
+      method: 'POST',
+      body: {
+        state: 'FAILED',
+        failureReason: 'DAEMON_RESTARTED',
+        summary: restartSummary({
+          name: config.name, previousPid: previous.pid, pid: process.pid, orphanStopped,
+          stopped: previous.stopped ?? null,
+        }),
+      },
+    }).catch((failure) => log(`  could not report it: ${failure.message}`));
+  }
+  await writeDriving(path, snapshotOf(process.pid, running))
+    .catch((failure) => log(`could not write ${path}: ${failure.message}`));
+}
+
+/**
+ * The old daemon's session, if it outlived it — and only if the pid still
+ * runs the command it was spawned with, because after a reboot that number
+ * may be somebody else's process.
+ */
+async function stopOrphan(left) {
+  if (!left.childPid || !left.command || !isAlive(left.childPid)) {
+    return false;
+  }
+  const command = await new Promise((resolveCommand) => {
+    const ps = spawn('ps', ['-o', 'command=', '-p', String(left.childPid)],
+      { stdio: ['ignore', 'pipe', 'ignore'] });
+    let out = '';
+    ps.stdout.on('data', (chunk) => (out += chunk));
+    ps.on('error', () => resolveCommand(''));
+    ps.on('close', () => resolveCommand(out));
+  });
+  if (!command.includes(left.command)) {
+    return false;
+  }
+  try {
+    process.kill(-left.childPid, 'SIGTERM');
+    log(`  stopped the session it left running (pid ${left.childPid})`);
+    return true;
+  } catch (failure) {
+    log(`  could not stop the session it left running: ${failure.message}`);
+    return false;
+  }
+}
+
+/**
+ * Keeps the note current: rewritten whenever the set of runs being driven
+ * changes, checked every second. A second is the window in which a death
+ * goes unreported — and the stale sweep still catches that one.
+ */
+function keepTheDrivingNote(config) {
+  const path = drivingPath(config.runnerId);
+  let written = null;
+  const timer = setInterval(() => {
+    const snapshot = snapshotOf(process.pid, running);
+    const text = JSON.stringify(snapshot);
+    if (text === written) return;
+    written = text;
+    writeDriving(path, snapshot).catch((failure) => {
+      written = null;
+      log(`could not write ${path}: ${failure.message}`);
+    });
+  }, 1000);
+  timer.unref?.();
+  return timer;
+}
+
 /**
  * A cancelled run reaches the runner on its next poll, and the child's whole
  * process group goes with it — an agent that spawns a build should not leave it
@@ -9060,6 +9332,24 @@ async function main() {
   // than buried under a session that then fails for a reason it explains.
   await probePermissionPrompt(config);
 
+  // R339. Whether this machine can put each session under a memory ceiling,
+  // and what an earlier daemon on this runner left behind when it died —
+  // both before anything is claimed: a run reported now is one the queue
+  // must not hand the checkout of to somebody else first.
+  const memoryMax = memoryMaxOf(config.sessionMemoryMax);
+  if (config.sessionMemoryMax && !memoryMax) {
+    log(`sessionMemoryMax "${config.sessionMemoryMax}" is not a size systemd reads (6G, 512M, 75%); ignored`);
+  }
+  const probed = await probeScope(memoryMax);
+  config.sessionScope = probed.scope;
+  if (probed.scope) {
+    log(`each session runs under MemoryMax=${probed.scope.memoryMax} (systemd --${probed.scope.manager} scope)`);
+  } else if (probed.why) {
+    log(`sessionMemoryMax not applied: ${probed.why}`);
+  }
+  await reportWhatARestartKilled(config);
+  const drivingNote = keepTheDrivingNote(config);
+
   // What this daemon SAYS it is, on every hello — R52's socket, R288's rule
   // that it describes the current state. One object, sent as-is by
   // `serveControl` and mutated by the SIGHUP handler below, so a terminal that
@@ -9347,6 +9637,12 @@ async function main() {
       }
       log('stopping; leaving any live run to the platform’s staleness sweep');
       stopping = true;
+      // R339. Said in the note before the sessions go, so the next daemon
+      // tells a stop somebody asked for from a kill nobody did.
+      clearInterval(drivingNote);
+      await writeDriving(drivingPath(config.runnerId),
+        { ...snapshotOf(process.pid, running), stopped: signal })
+        .catch(() => undefined);
       clearInterval(heartbeat);
       clearInterval(gitSurvey);
       clearInterval(workspaceRequests);

package/runner/sign-in.mjs

@@ -26,6 +26,9 @@ export class Session {
     this.url = String(url).replace(/\/+$/, '');
     this.cookies = new Map();
     this.email = null;
+    /** Called once when a signed-in session is answered 401 — expired, or
+     *  revoked on the platform. The terminal offers `/login` from there. */
+    this.onExpired = null;
   }
 
   get signedIn() {
@@ -63,6 +66,14 @@ export class Session {
     });
     this.#remember(response);
     const text = await response.text();
+    if (response.status === 401 && this.email !== null) {
+      // The cookie stopped meaning anything: expired, signed out elsewhere, or
+      // the account revoked. Until this every action failed one at a time with
+      // a bare "HTTP 401" while the footer still named the person — so the
+      // state is put right HERE, where every request passes, and said once.
+      this.email = null;
+      this.onExpired?.();
+    }
     if (!response.ok) {
       const failure = new Error(messageIn(text) ?? `${method} ${path} failed: HTTP ${response.status}`);
       failure.status = response.status;