cawdev-cli 1.0.6-beta → 1.0.7-beta

package/mcp/server.mjs

@@ -1651,9 +1651,13 @@ async function decide(config, args) {
     }
     // EXPIRED, or the poll gave up before the platform expired it. Same answer
     // either way, and the difference is on the run for whoever reads it later.
+    // R339: a person may still allow it late, and if they do the session is
+    // sent a message saying so — so this says to carry on, not to stop.
     return deny(
-      `Nobody answered this permission request in time. Do not retry it in a loop: report ` +
-        `blocked, say exactly what you needed to run and why, and let a person allow it.`,
+      `Nobody answered this permission request in time. Do not retry it in a loop. Carry on ` +
+        `with whatever does not need it; if a person allows it later you will be sent a ` +
+        `message saying so, and may run it then. If nothing else can be done without it, ` +
+        `report blocked and say exactly what you needed to run and why.`,
     );
   } catch (failure) {
     return deny(
@@ -1806,9 +1810,10 @@ function skillServers() {
 /**
  * Waits for somebody to decide, for as long as the platform will hold it open.
  *
- * Bounded a little beyond the platform's own expiry so the two cannot both be
- * waiting on each other: if the sweep is late, this gives up and denies, which
- * is the same answer the sweep would have produced.
+ * R339: the platform's wait is the project's setting now, and may be never,
+ * so this has no deadline of its own: it returns when the request stops being
+ * PENDING — allowed, refused, or expired by the platform's sweep. A test may
+ * still bound it.
  */
 async function pollForDecision(config, project, runId, approvalId) {
   const deadline = Date.now() + approvalTimeoutSeconds() * 1000;
@@ -1831,10 +1836,10 @@ async function pollForDecision(config, project, runId, approvalId) {
   return null;
 }
 
-/** A little past the platform's own fifteen-minute expiry. Overridable for tests. */
+/** For ever: the platform decides when nobody is coming (R339). Overridable for tests. */
 function approvalTimeoutSeconds() {
   const configured = Number(process.env.CAWDEV_APPROVAL_TIMEOUT_SECONDS);
-  return Number.isFinite(configured) && configured > 0 ? configured : 960;
+  return Number.isFinite(configured) && configured > 0 ? configured : Infinity;
 }
 
 // There is no roadmap_delete or changelog_delete, and there will not be. The

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cawdev-cli",
-  "version": "1.0.6-beta",
+  "version": "1.0.7-beta",
   "description": "cawdev's terminal client and runner daemon — zero dependencies, on purpose",
   "type": "module",
   "bin": {

package/runner/README.md

@@ -68,6 +68,13 @@ page and waits for you to approve a code; after that it is remembered, and
 `/login` does it again on demand. No password is ever typed into the terminal —
 that belongs on a page your browser has told you the origin of.
 
+When the platform stops honouring that session — it expired, you signed out in
+the console, or your account went — the first request answered 401 says so
+once, the footer pins `session expired — /login to sign in again`, and the
+terminal drops to watching only until `/login` succeeds. The polls pick up again
+on their own after it. In advanced mode `/login` stays in advanced mode: the URL
+and the code are printed in the prompt window.
+
 ```
 cawdev                    the runner here, starting one if there is none
 cawdev --runner <name>    when this machine runs more than one
@@ -222,7 +229,10 @@ move through the command list while one is open.
 | `/quit` | leave |
 
 **Typing `/` filters that list as you go**, each row with its description; arrows
-and `enter` pick one and `tab` completes as far as the matches agree. Guessing a
+and `enter` pick one and `tab` completes as far as the matches agree — then
+moves down the list, so `/lo` `tab` `tab` reaches `/login` past `/log`. A name
+typed in full is the first row, so `/log` `enter` runs `/log`. Advanced mode
+draws the same list above its prompt, six rows at a time. Guessing a
 command name and being told `no such command` is a step, and it is the step this
 removes.
 
@@ -1200,6 +1210,39 @@ A run **`WAITING_ON_USER` is never swept.** That is the one state where nothing
 happening is correct: it is stalled on a person, who may reasonably take a day.
 Nor is a `PAUSED` or `USAGE_LIMITED` one (below) — there is no process to lose.
 
+### When the daemon itself was killed (R339)
+
+A daemon that dies and is restarted — by systemd, by `cawdev`, by hand — comes
+back with nothing in its hands, and the platform could only infer that five
+minutes later, as "its runner is alive but stopped driving it". So the daemon
+keeps a note of the runs it is driving (`~/.cawdev/driving/<runner id>.json`,
+rewritten when the set changes), and on boot the next one reads it: every run
+the dead daemon was driving that the platform still believes in is failed **at
+once** as `DAEMON_RESTARTED`, with the old and new pids and where to look for the
+cause. A session the old daemon left running is stopped first — only when its
+pid still runs the command it was spawned with. The workspace is held exactly as
+for a vanished runner, and a machine with **auto-resume** on carries such a run
+on by itself **once**; a second restart on the same run waits for a person,
+because a test suite that killed the daemon twice will kill it a third time.
+
+The usual cause on a small Linux box is memory: the session runs a test suite,
+the kernel's OOM killer picks the biggest process, and that is sometimes the
+daemon. `journalctl -k | grep -i "killed process"` says so. Two fixes, both on
+the machine:
+
+- **`"sessionMemoryMax": "6G"`** in `runner.config.json` spawns each agent
+  session under `systemd-run --scope -p MemoryMax=…` (a size systemd reads —
+  `6G`, `512M`, `75%`). A session that blows through it is killed on its own,
+  the ordinary "agent was terminated" failure, and the daemon stays up. Linux
+  only, and it needs a systemd manager for the user (`loginctl enable-linger
+  <user>` on a box with nobody logged in) or a daemon running as root; the
+  daemon probes once at boot and says in its log whether it applied. Needs a
+  restart to change.
+- **Protect the daemon and give the box room**: in the daemon's systemd unit,
+  `OOMScoreAdjust=-800` makes the kernel pick a test worker over the daemon;
+  and add swap (`fallocate -l 4G /swapfile && chmod 600 /swapfile && mkswap
+  /swapfile && swapon /swapfile`, plus its `/etc/fstab` line).
+
 ## When the usage limit hits (R73)
 
 Claude Code stops with a message naming the window — the five-hour one or the
@@ -1309,8 +1352,11 @@ your inbox and on the run, and waits for an answer. Allow it once, or allow it
 always here — which writes a rule on the project that every runner serving it
 inherits.
 
-Nobody answering is a decision too: after fifteen minutes the request expires
-and the session is told to report blocked rather than wait for ever.
+Nobody answering is a decision too: after the project's wait — fifteen minutes
+unless its Rules page says otherwise, and possibly never (R339) — the request
+expires and the session is told to carry on without it. Allowing it later still
+works: the grant lasts the rest of the run and the session is sent a message to
+try again. A stage gate never expires.
 
 You can still say in advance what a project may do, and for anything a session
 needs on every run that is the better answer — with `allowedTools`, which

package/runner/attach.mjs

@@ -482,7 +482,7 @@ export function elapsed(ms) {
  */
 export function footerLines(state, width, ink = painter(3)) {
   const {
-    runner, runs = [], email, watching, connected = true,
+    runner, runs = [], email, expired = false, watching, connected = true,
     banner = [], overlay = [], input = null, keys = '', status = '',
     running = null, now = Date.now(), matches = [],
   } = state;
@@ -519,6 +519,16 @@ export function footerLines(state, width, ink = painter(3)) {
     ), width));
   }
 
+  // The platform refused the stored session (401). Pinned for the same reason
+  // as the row above: one line in the scrollback is gone with the next
+  // transcript line, and every action from here on would fail without it.
+  if (expired) {
+    lines.push(padVisible(clip(
+      ` ${ink.warn('!')} ${ink.muted('session expired —')} ${ink.text('/login')} ${ink.muted('to sign in again')}`,
+      width,
+    ), width));
+  }
+
   // Who and where. The runner's NAME is what the console shows and what
   // `--runner` takes, so it is the word somebody would type; the email is what
   // every action here is done as, and "watching only" is not a lesser state,
@@ -679,19 +689,19 @@ async function openSession(argv, url) {
  * too is not belt and braces: a machine over ssh has no browser to open, and
  * this is the only thing that makes it work at all.
  */
-async function runSignIn(session, ink = painter()) {
+async function runSignIn(session, ink = painter(), say = (line) => console.log(line)) {
   const outcome = await signInThroughBrowser(session, ({ url, code }) => {
-    console.log(`  ${ink.muted('If your browser did not open, go to')}`);
-    console.log(`      ${ink.accent(url)}`);
-    console.log(`  ${ink.muted('and check it is showing')}  ${ink.bold(code)}\n`);
-    console.log(`  ${ink.muted('Waiting…')}`);
+    say(`  ${ink.muted('If your browser did not open, go to')}`);
+    say(`      ${ink.accent(url)}`);
+    say(`  ${ink.muted('and check it is showing')}  ${ink.bold(code)}\n`);
+    say(`  ${ink.muted('Waiting…')}`);
   });
   if (outcome.signedIn) {
-    console.log(`  ${ink.success('Signed in')} as ${ink.bold(outcome.email)}.\n`);
+    say(`  ${ink.success('Signed in')} as ${ink.bold(outcome.email)}.\n`);
   } else if (outcome.refused) {
-    console.log(`  ${ink.danger('Refused')} in the browser.\n`);
+    say(`  ${ink.danger('Refused')} in the browser.\n`);
   } else {
-    console.log(`  ${ink.warn('The code expired.')}\n`);
+    say(`  ${ink.warn('The code expired.')}\n`);
   }
   return outcome;
 }
@@ -801,6 +811,9 @@ function refOf(word) {
   return word.replace(/^r/i, 'R').replace(/^i/i, 'i');
 }
 
+/** How many matching commands advanced mode's prompt shows at once. */
+const SPLIT_COMPLETIONS = 6;
+
 /** The slash commands, and the one place they are described. */
 const COMMANDS = [
   ['/help', 'this list'],
@@ -887,6 +900,11 @@ export class Attached {
   constructor(socketPath, session, options = {}) {
     this.socketPath = socketPath;
     this.session = session;
+    if (session) {
+      session.onExpired = () => this.sessionExpired();
+    }
+    /** True from a 401 on a session that was signed in until `/login` works. */
+    this.expired = false;
     this.options = options;
     this.ink = painter();
     this.screen = new Scrollback(options.out ?? process.stdout);
@@ -1864,8 +1882,16 @@ export class Attached {
       }
       if (rows.length) {
         // As far as they agree, which is what every shell does and nobody has
-        // to be taught. One match completes it whole.
-        line.set(commonPrefix(rows.map(([name]) => name)));
+        // to be taught. One match completes it whole. Once the line is already
+        // that far, Tab moves down the list instead — `/log` is a command AND
+        // the prefix of `/login` and `/logout`, and Tab stopping there for
+        // good left those two reachable only by the arrows.
+        const prefix = commonPrefix(rows.map(([name]) => name));
+        if (rows.length > 1 && line.text.toLowerCase() === prefix.toLowerCase() && this.input.showing !== false) {
+          this.input.at = (at + 1) % rows.length;
+        } else {
+          line.set(prefix);
+        }
         this.input.showing = true;
         this.dirty = true;
       }
@@ -2829,21 +2855,31 @@ export class Attached {
    * the moment it is decided.
    */
   async signIn() {
+    let say;
     if (this.split) {
-      this.leaveSplit();
+      // Advanced mode stays: the URL and the code go to the prompt window,
+      // where everything said there is read, and the browser opens anyway.
+      say = (line) => this.say(line);
+    } else {
+      // Everything queued goes out first and the footer comes down, so what
+      // `runSignIn` prints with `console.log` lands under the transcript rather
+      // than through the middle of a live region nothing is going to erase.
+      this.say('');
+      this.screen.update(this.pending, []);
+      this.pending = [];
     }
-    // Everything queued goes out first and the footer comes down, so what
-    // `runSignIn` prints with `console.log` lands under the transcript rather
-    // than through the middle of a live region nothing is going to erase.
-    this.say('');
-    this.screen.update(this.pending, []);
-    this.pending = [];
-    const outcome = await runSignIn(this.session, this.ink)
+    const outcome = await runSignIn(this.session, this.ink, say)
       .catch((failure) => ({ signedIn: false, message: failure.message }));
     if (outcome.message) {
       this.say(this.ink.danger(`  could not sign in: ${outcome.message}`));
     }
-    if (this.session.signedIn) {
+    if (this.session.signedIn && this.expired) {
+      // After an expiry the watchers never stopped — they have been failing
+      // quietly and pick up on their own — so a second set would poll twice.
+      this.expired = false;
+      this.note('signed in again');
+      void this.findStopped();
+    } else if (this.session.signedIn) {
       void this.watchInbox();
       void this.watchQuestions();
       void this.findStopped();
@@ -2852,6 +2888,20 @@ export class Attached {
     return undefined;
   }
 
+  /**
+   * The platform answered 401 to a session that was signed in: it expired, was
+   * signed out from the console, or the account went. Said once, where it is
+   * read — the prompt window in advanced mode, the scrollback otherwise — and
+   * the footer keeps a row until `/login` succeeds. The watchers keep polling
+   * and fail quietly; they pick up again on their own after the sign-in.
+   */
+  sessionExpired() {
+    if (this.expired) return;
+    this.expired = true;
+    this.say(this.ink.warn('  your cawdev session has expired or is no longer valid — type /login to sign in again'));
+    this.note('session expired — /login to sign in again');
+  }
+
   // --- advanced mode — split.mjs ----------------------------------------------
 
   /**
@@ -3219,7 +3269,16 @@ export class Attached {
         + ' · / commands · tab next window');
     // A question or a request on screen says which window it came from.
     const from = banner.length ? [ink.bold(ink.warn(` from ${this.tagOf(current)}`))] : [];
-    const fixed = [...from, ...banner, ...overlay, input];
+    // The commands matching what is typed, above the line as in the footer —
+    // advanced mode drew none, so enter took a highlighted command nobody saw.
+    const matches = this.mode === 'typing' && this.input?.showing !== false ? this.matching() : { rows: [], at: 0 };
+    // Six rows at most, scrolled to the highlighted one: a bare `/` matches
+    // every command, and the prompt grows with what it holds.
+    const first = Math.max(0, Math.min(matches.at - 2, matches.rows.length - SPLIT_COMPLETIONS));
+    const completing = completionLines(
+      matches.rows.slice(first, first + SPLIT_COMPLETIONS), matches.at - first, inner, ink,
+    );
+    const fixed = [...from, ...banner, ...overlay, ...completing, input];
     const promptRows = Math.max(PROMPT_ROWS, fixed.length + 5);
     // The roadmap across the top: as tall as its fullest column needs, never
     // more than a third of the screen, and never so tall that no window fits
@@ -4561,6 +4620,7 @@ export class Attached {
       runner: this.runner,
       runs: this.runs,
       email: this.session.email,
+      expired: this.expired,
       watching: run,
       connected: this.connected,
       // R83's status line is about what this machine is DRIVING, which is not

package/runner/input.mjs

@@ -192,7 +192,11 @@ export function completions(text, commands) {
     return [];
   }
   const word = typed.slice(1).toLowerCase();
-  return commands.filter(([name]) => name.slice(1).toLowerCase().startsWith(word));
+  const found = commands.filter(([name]) => name.slice(1).toLowerCase().startsWith(word));
+  // A name typed in full comes first, so enter runs `/log` and not `/login`,
+  // the first longer one in the list.
+  const exact = found.filter(([name]) => name.slice(1).toLowerCase() === word);
+  return [...exact, ...found.filter((row) => !exact.includes(row))];
 }
 
 /**

package/runner/restart.mjs

@@ -0,0 +1,191 @@
+// What a daemon that restarted under its sessions does about them — R339.
+//
+// A daemon killed mid-run (most often for memory, by the kernel, while the
+// session ran a test suite) comes back healthy with an empty `running` map.
+// The platform could only infer what happened: five minutes later
+// StaleRunSweeper failed the run as "its runner is alive but stopped driving
+// it", a sentence that names no cause and arrives after somebody has already
+// gone looking. The one process that KNOWS is the new daemon, so the old one
+// leaves a note: the runs it is driving, written beside the socket every time
+// that set changes. On boot the new one reads it and reports each run it no
+// longer holds as DAEMON_RESTARTED, at once.
+//
+// And so it happens less: `sessionMemoryMax` spawns each agent in a systemd
+// scope with a memory ceiling, so a runaway test suite takes down its own
+// session — the ordinary "agent was terminated" path — and not the daemon.
+//
+// Pure where it can be. The file, the scope probe and the kill are the only
+// side effects, and each takes what it touches as an argument.
+
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+
+/**
+ * Where a runner's note lives — one per runner id, because one machine may
+ * run two configs. NOT in the run directory, which holds sockets and nothing
+ * else (the terminal lists it to find daemons): beside it, so a test that
+ * points CAWDEV_RUN_DIR at a temporary directory keeps its notes there too.
+ */
+export function drivingPath(runnerId, env = process.env) {
+  const dir = env.CAWDEV_DRIVING_DIR
+    ?? (env.CAWDEV_RUN_DIR ? `${env.CAWDEV_RUN_DIR}-driving` : join(homedir(), '.cawdev', 'driving'));
+  return join(dir, `${runnerId}.json`);
+}
+
+/**
+ * The note: who wrote it and what it was driving. `command` is the child's
+ * command's base name, so the next daemon can tell its own orphan from an
+ * unrelated process that was handed the same pid after a reboot.
+ */
+export function snapshotOf(pid, running) {
+  const runs = [];
+  for (const [id, child] of running) {
+    runs.push({
+      id,
+      projectSlug: child?.cawdevProjectSlug ?? null,
+      childPid: Number.isInteger(child?.pid) ? child.pid : null,
+      command: child?.cawdevCommand ? basename(child.cawdevCommand) : null,
+    });
+  }
+  return { pid, runs };
+}
+
+/** Atomic: a daemon killed mid-write must not leave half a note for the next one. */
+export async function writeDriving(path, snapshot) {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(snapshot), { mode: 0o600 });
+  await rename(temporary, path);
+}
+
+/** The previous note, or null — a missing or unreadable one is "nothing was being driven". */
+export async function readDriving(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, 'utf8'));
+    return parsed && Number.isInteger(parsed.pid) && Array.isArray(parsed.runs) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The runs a previous daemon left behind, or none.
+ *
+ * None when the note is this process's own, and none when its writer is
+ * still alive: that is a second daemon on the same runner id, and its runs
+ * are its own business.
+ */
+export function leftBehind(previous, myPid, isAlive) {
+  if (!previous || previous.pid === myPid || isAlive(previous.pid)) {
+    return [];
+  }
+  return previous.runs.filter((run) => typeof run.id === 'string' && run.projectSlug);
+}
+
+/** Whether a pid is a live process. Signal 0 tests without sending. */
+export function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (failure) {
+    return failure.code === 'EPERM';
+  }
+}
+
+/** Live states a restart does not concern: they hold no process. */
+const NOT_DRIVEN = new Set(['QUEUED', 'PAUSED', 'USAGE_LIMITED']);
+
+/**
+ * Whether the platform's view of a run means a restart killed it: live,
+ * holding a process, and still this runner's. A run carried on elsewhere in
+ * the meantime is not ours to fail.
+ */
+export function killedByRestart(run, runnerId) {
+  return Boolean(run?.live)
+    && !NOT_DRIVEN.has(run.state)
+    && (!run.runnerId || run.runnerId === runnerId);
+}
+
+/**
+ * What the run says — the cause, the evidence to look for, and the way out.
+ * `stopped` is the signal a daemon that stopped ON PURPOSE wrote into its
+ * note; without one it was killed, and memory is the usual reason.
+ */
+export function restartSummary({ name, previousPid, pid, orphanStopped, stopped = null }) {
+  const why = stopped
+    ? `It was stopped (${stopped}) — by somebody, or by the service manager restarting it.`
+    : 'Most often the machine ran out of memory — `journalctl -k | grep -i "killed process"` '
+      + 'says so on Linux; `sessionMemoryMax` in the runner config keeps a session from taking '
+      + 'the daemon with it.';
+  return `The cawdev daemon on ${name} restarted while driving this run (it was pid `
+    + `${previousPid}; it is pid ${pid} now), and the agent session went with it. ${why}`
+    + (orphanStopped ? ' The session it left running unattended has been stopped.' : '')
+    + ' The workspace is kept with whatever the session had written: carry it on there, or '
+    + 'discard it.';
+}
+
+// --- the memory ceiling ----------------------------------------------------
+
+/**
+ * `sessionMemoryMax` as systemd reads it — `6G`, `512M`, `75%` — or null.
+ * Anything else is null, and the daemon says so rather than guessing.
+ */
+export function memoryMaxOf(value) {
+  if (value === undefined || value === null || value === '') return null;
+  const text = String(value).trim();
+  return /^\d+(\.\d+)?[KMGT]?$|^\d+(\.\d+)?%$/i.test(text) ? text.toUpperCase() : null;
+}
+
+/**
+ * The command line that runs `command args` under the ceiling — or the same
+ * command line, when there is no ceiling to apply. `systemd-run --scope` execs
+ * the command in place, so the pid, the process group and the pipes are the
+ * agent's own: cancelling (`kill(-pid)`) and the stream readers do not change.
+ */
+export function scoped(command, args, scope) {
+  if (!scope?.memoryMax) {
+    return { command, args };
+  }
+  return {
+    command: 'systemd-run',
+    args: [`--${scope.manager}`, '--scope', '--quiet', '--collect', '--no-ask-password',
+      '-p', `MemoryMax=${scope.memoryMax}`, '--', command, ...args],
+  };
+}
+
+/**
+ * Whether this machine can apply the ceiling: Linux, and a systemd that will
+ * make a scope for this user. Tried with `true` once at boot, because a
+ * daemon run as a system service has no user manager and every spawn would
+ * otherwise fail on a command that cannot work here.
+ */
+export async function probeScope(memoryMax, { platform = process.platform, run = runQuietly } = {}) {
+  if (!memoryMax) return { scope: null, why: null };
+  if (platform !== 'linux') {
+    return { scope: null, why: `sessionMemoryMax needs Linux and systemd; this is ${platform}` };
+  }
+  for (const manager of ['user', 'system']) {
+    const code = await run('systemd-run',
+      [`--${manager}`, '--scope', '--quiet', '--collect', '--no-ask-password',
+        '-p', `MemoryMax=${memoryMax}`, 'true']);
+    if (code === 0) {
+      return { scope: { manager, memoryMax }, why: null };
+    }
+  }
+  return {
+    scope: null,
+    why: 'systemd-run could not make a scope here (no user manager — `loginctl enable-linger` '
+      + 'for this user, or run the daemon as root)',
+  };
+}
+
+function runQuietly(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: 'ignore' });
+    child.on('error', () => resolve(-1));
+    child.on('close', (code) => resolve(code));
+  });
+}

package/runner/runner.mjs

@@ -48,6 +48,10 @@ import {
 } from './auto-workspaces.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 -----------------------------------------------------------
 
@@ -420,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,
@@ -6755,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
@@ -6858,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);
@@ -6869,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'}`);
@@ -6879,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,
@@ -7306,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.
@@ -8418,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,
@@ -8757,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,
@@ -8939,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
@@ -9191,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
@@ -9478,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;