@bridge4dev/runner 0.64.1 → 0.65.1

package/dist/session-cage.js

@@ -367,6 +367,45 @@ export function sessionScopeUnit(id, attempt = 1) {
     const base = `${SESSION_SCOPE_PREFIX}${sanitizeCageId(id)}`;
     return attempt <= 1 ? `${base}.scope` : `${base}-r${attempt}.scope`;
 }
+/**
+ * How many names one start may walk through before giving up and letting
+ * systemd refuse it (#431). Three is two more than has ever been needed.
+ */
+const CAGE_NAME_MAX_TRIES = 3;
+/**
+ * Is there a cgroup by this unit's name — that is, processes still in it?
+ *
+ * `dirOf` is the test seam: the answer depends on a cgroup tree, and a suite
+ * has none. Everything else about this function is one `stat`.
+ */
+export function cageCgroupExists(unit, dirOf = scopeCgroupDir) {
+    const dir = dirOf(unit);
+    if (dir === null)
+        return false;
+    try {
+        return fs.existsSync(dir);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Put out the cage that is holding a name this session needs, and say so if it
+ * would not go.
+ *
+ * Loud on failure, because the fallback is the dangerous one: the start moves
+ * to `-r2` either way, and if the old tree is STILL running under the old name
+ * the agent that comes back will start the same command beside it — two runs of
+ * one build in one folder (independent review of #431). Nothing here can undo
+ * that; the machine's log is what lets a person see it happened.
+ */
+function defaultStopCage(unit) {
+    void stopSessionScope(unit).then((stopped) => {
+        if (!stopped) {
+            log.warn('session cage: the cage holding this name would not stop', { unit });
+        }
+    });
+}
 // ─── capability detection ────────────────────────────────────────────
 /** cgroup v2 unified, from `statfs` — the number behind `stat -fc %T`. */
 const CGROUP2_SUPER_MAGIC = 0x63677270;
@@ -874,7 +913,13 @@ export function cageSpawn(input) {
  * who may hand it. One function could not do both — a test process legitimately
  * needs the first answer and must never get the second.
  */
-export function buildCagedSpawn(input) {
+export function buildCagedSpawn(input, 
+/**
+ * The two things this function does to the machine besides building a command
+ * line, as seams (#431): whether a cage of that name still exists, and what to
+ * do about it. A suite has neither a cgroup tree nor a systemd to answer.
+ */
+io = {}) {
     const facts = sessionCage();
     if (facts.mode !== 'scope' ||
         facts.memoryMaxBytes === null ||
@@ -896,9 +941,64 @@ export function buildCagedSpawn(input) {
     const maxBytes = live?.maxBytes ?? facts.memoryMaxBytes;
     const swapMaxBytes = live?.swapBytes ?? facts.swapMaxBytes;
     const guaranteedBytes = live?.guaranteedBytes ?? null;
-    const attempt = (attempts.get(input.id) ?? 0) + 1;
+    let attempt = (attempts.get(input.id) ?? 0) + 1;
+    let unit = sessionScopeUnit(input.id, attempt);
+    /**
+     * The last line of defence: a name that is STILL taken (#431).
+     *
+     * The counter above is memory, and memory is exactly what a restarted daemon
+     * does not have: after `systemctl restart` it starts at one again and asks
+     * for the plain `devbridge-session-<id>.scope` — the name the previous life
+     * of this session may still be holding with a build nobody killed. systemd
+     * answers «was already loaded or has a fragment file» and exits 1, and the
+     * session dies before it starts (the whole of #431).
+     *
+     * Asked of the cgroup tree rather than of systemd on purpose: this runs on
+     * the start of every session, and the bus has been measured at 2.7 s under
+     * load. A directory that exists means processes are in it, which is the case
+     * that matters; a unit left `failed` and EMPTY has no directory, and the
+     * sweep at daemon start clears those by name.
+     *
+     * And the tree is not left to run under a different name. It cannot hand its
+     * output to anybody — the pipes died with the process that started it — while
+     * the agent coming back will start the same command again: two `docker
+     * compose` runs of one project in one folder is a worse outcome than the
+     * failure this guard exists to prevent.
+     */
+    const exists = io.cageExists ?? cageCgroupExists;
+    const liveness = io.cageLiveness ?? scopeOwnerLiveness;
+    const stop = io.stopCage ?? defaultStopCage;
+    for (let tries = 0; tries < CAGE_NAME_MAX_TRIES && exists(unit); tries += 1) {
+        /**
+         * Asked of the kernel, not of this process's memory (independent review of
+         * #431).
+         *
+         * The first version compared the name against `liveUnits` and stopped
+         * anything that was not in it. That register holds ONE unit per session, so
+         * in the shape it was meant to protect — two processes of one session,
+         * #401 — the live cage is the one MISSING from it, and the guard would have
+         * put out an agent somebody was using. `scopeOwnerLiveness` answers the
+         * question that actually matters, on evidence: `orphaned` and `empty` are
+         * the previous life of this session, and nothing else may be touched.
+         */
+        const state = liveness(unit);
+        if (state === 'orphaned' || state === 'empty') {
+            log.warn('session cage: the name of this cage is still taken, stopping what is left in it', {
+                unit,
+                liveness: state,
+            });
+            stop(unit);
+        }
+        else {
+            log.warn('session cage: the name of this cage is taken by something alive, leaving it', {
+                unit,
+                liveness: state,
+            });
+        }
+        attempt += 1;
+        unit = sessionScopeUnit(input.id, attempt);
+    }
     attempts.set(input.id, attempt);
-    const unit = sessionScopeUnit(input.id, attempt);
     liveUnits.set(input.id, unit);
     // A verdict nobody read belongs to the process that just ended, not to the
     // one starting now: without this, a kill that was never surfaced would be
@@ -1281,6 +1381,31 @@ export function stoppedProcesses(count, where = 'it') {
         ? `a process in ${where} was stopped`
         : `${count} processes in ${where} were stopped`;
 }
+/**
+ * What the feed says when the runner takes a session's cage down with itself
+ * (#431).
+ *
+ * Next to {@link stoppedProcesses} and for the same reason: two places that
+ * count the same thing must not word it differently. This one counts COMMANDS,
+ * because that is what a person can act on — «7 processes» is the same build
+ * said in a way nobody can use.
+ *
+ * The middle sentence is the part that matters. A command that outlives the
+ * process which started it cannot hand its output back to anybody: the pipe
+ * died with the agent, and the agent that comes back is a different process
+ * with a different tool call. Stopping it is not a loss, it is the refusal to
+ * keep a zombie — but the person has to be told, or they will wait for a build
+ * that nobody is going to report.
+ */
+export function restartStoppedCommands(count) {
+    return count === 1
+        ? 'The runner was restarted, so the command this session had running was stopped. ' +
+            'Nothing can hand its output back now — start it again if you still need it. ' +
+            'The session itself is fine: its conversation was not touched.'
+        : `The runner was restarted, so the ${count} commands this session had running were stopped. ` +
+            'Nothing can hand their output back now — start them again if you still need them. ' +
+            'The session itself is fine: its conversation was not touched.';
+}
 const deaths = new Map();
 /**
  * Snapshot the cgroup's verdict before systemd can take it away.
@@ -1373,11 +1498,28 @@ function showValue(stdout, property) {
  * startable in the meantime.
  */
 export async function releaseSessionScope(unit, id, systemctl = realSystemctl) {
-    const running = releaseSessionScopeInner(unit, id, systemctl);
+    /**
+     * Is the scope being released the one this session is CURRENTLY in?
+     *
+     * It usually is, and then everything below behaves as it always did. It is
+     * not when the agent was relaunched while the previous process was still on
+     * its way out — the one-shot relaunches empty the slot when the event stream
+     * ends, and the CLI's `exit` lands a second or two later. By then the
+     * register names the LIVE cage, and wiping it by session id threw away the
+     * only record of it: the memory watch lost the cgroup, the sweep lost a
+     * spare, and since #431 `shutdown()` reads exactly this to decide whose cage
+     * to put out — «this session has no cage» would have left the live one
+     * running, which is the defect this ticket is about. Found by the
+     * independent review of #431.
+     */
+    const current = unit !== null && id !== undefined && liveUnits.get(id) === unit;
+    const running = releaseSessionScopeInner(unit, id, systemctl, current);
     if (id !== undefined) {
         // The process this named is gone with the scope; a pid outliving it would be
-        // a pid that means something else by the time anybody reads it.
-        agentPids.delete(id);
+        // a pid that means something else by the time anybody reads it. Only when
+        // this IS that process — see `current` above.
+        if (current)
+            agentPids.delete(id);
         releasing.set(id, running);
         void running.finally(() => {
             if (releasing.get(id) === running)
@@ -1416,7 +1558,9 @@ export async function memoryDeathSentence(id, capMs = 3_000) {
     }
     return explainMemoryDeath(id);
 }
-async function releaseSessionScopeInner(unit, id, systemctl) {
+async function releaseSessionScopeInner(unit, id, systemctl, 
+/** Is this the cage the session is in right now — see {@link releaseSessionScope}. */
+current) {
     if (!unit)
         return null;
     // Synchronously and FIRST: the cgroup's own counters are the one record of an
@@ -1425,7 +1569,7 @@ async function releaseSessionScopeInner(unit, id, systemctl) {
     // empty. This is what the adapter's error text is built from (#387).
     if (id !== undefined)
         rememberDeath(id, unit);
-    if (id !== undefined)
+    if (id !== undefined && current)
         liveUnits.delete(id);
     let result = null;
     let tasksLeft = null;
@@ -1504,10 +1648,45 @@ async function releaseSessionScopeInner(unit, id, systemctl) {
     // which systemd answers with «was already loaded or has a fragment file» and
     // spawns nothing — the exact failure the counter exists to prevent
     // (QA-2026-09-07 MINOR-11).
-    if (id !== undefined && forgotten)
+    if (id !== undefined && forgotten && current)
         attempts.delete(id);
     return result;
 }
+/**
+ * Stop a cage and let systemd forget its name — the other half of killing the
+ * agent (#431, грабля §524).
+ *
+ * {@link releaseSessionScope} is the path for a process that ENDED: it reads
+ * the verdict first and only stops what is left. This one is for the two
+ * moments where there is nothing to read and no time to read it — the daemon
+ * going down, and a start that found its own name still taken. It asks for the
+ * stop and nothing else.
+ *
+ * Worth knowing on the shutdown path: once `stop` has been accepted, the job
+ * belongs to systemd. A caller that gives up waiting still gets the cage
+ * stopped — it simply does not get to see it happen.
+ */
+export async function stopSessionScope(unit, systemctl = realSystemctl) {
+    if (!unit)
+        return false;
+    let stopped = false;
+    try {
+        await systemctl(['stop', unit]);
+        stopped = true;
+    }
+    catch (error) {
+        // A scope that ended by itself answers «not loaded», and a process with no
+        // right to act on cages answers with a refusal. Neither is worth a session.
+        log.debug('session cage: could not stop the scope', { unit, error: String(error) });
+    }
+    try {
+        await systemctl(['reset-failed', unit]);
+    }
+    catch {
+        // Nothing to forget: the usual answer for a scope that stopped cleanly.
+    }
+    return stopped;
+}
 /** Unit names of every `devbridge-session-*.scope` systemd still knows about. */
 export async function listSessionScopeUnits(systemctl = realSystemctl) {
     let stdout;
@@ -1568,6 +1747,17 @@ export async function listSessionScopes(systemctl = realSystemctl) {
     }
     return out;
 }
+/**
+ * Did this read fail because the process is gone, or because we could not read?
+ *
+ * `ENOENT` is /proc's answer for a pid that ended; `ESRCH` is the same answer
+ * from the other syscalls. Everything else — permissions, descriptors, a broken
+ * read — is ignorance, and ignorance is never evidence of litter.
+ */
+function processIsGone(error) {
+    const code = error?.code;
+    return code === 'ENOENT' || code === 'ESRCH';
+}
 export function scopeOwnerLiveness(unit, io = {}) {
     const readFile = io.readFile ?? ((p) => fs.readFileSync(p, 'utf8'));
     const cgroupDir = io.cgroupDir ?? scopeCgroupDir;
@@ -1597,6 +1787,19 @@ export function scopeOwnerLiveness(unit, io = {}) {
     }
     if (pids.length === 0)
         return 'empty';
+    /**
+     * Who is INSIDE, as a set — the difference between «a live parent» and «a
+     * live parent outside the cage» (#431).
+     *
+     * An agent's command is never one process: `bash -lc 'docker compose …'` is a
+     * tree, and every process below its root has a living parent — its own
+     * neighbour in this cgroup. Without this set the question below answered
+     * «somebody is supervising them» for every abandoned build on the machine,
+     * so the sweep left it alone for ever, the cage kept its name, and the next
+     * start of that session died as «(code 1)» (measured 16.09.2026). The single
+     * orphan of §479 answered correctly only because it had no children.
+     */
+    const inside = new Set(pids);
     let sawUnknown = false;
     for (const pid of pids) {
         let ppid;
@@ -1606,8 +1809,23 @@ export function scopeOwnerLiveness(unit, io = {}) {
             const value = line === undefined ? Number.NaN : Number(line.slice('PPid:'.length).trim());
             ppid = Number.isSafeInteger(value) ? value : null;
         }
-        catch {
-            // Ended between the listing and the read — says nothing either way.
+        catch (error) {
+            /**
+             * Two different answers wearing one coat, and the difference decides
+             * whether a live session may be stopped (независимая проверка #431).
+             *
+             * `ENOENT`/`ESRCH` is the kernel saying the process ended between the
+             * listing and the read — it says nothing either way, and the scan goes
+             * on. Anything else (`EACCES` under `hidepid`, `EMFILE` on a busy
+             * daemon, `EIO`) is a /proc we could not read, and «could not read» has
+             * exactly one safe reading in this function: `unknown`, which is never
+             * swept. Until the tree rule above, a live session survived this by
+             * accident — its neighbours' parents were alive; now the agent's own
+             * line is the only voice for «somebody is working here», and losing it
+             * must not read as «litter».
+             */
+            if (!processIsGone(error))
+                sawUnknown = true;
             continue;
         }
         if (ppid === null) {
@@ -1618,6 +1836,10 @@ export function scopeOwnerLiveness(unit, io = {}) {
         // answer for a process that is going away.
         if (ppid <= 1)
             continue;
+        // A parent in the SAME cage is a neighbour, not an owner: it is part of the
+        // same abandoned tree, and its own parent is asked about in its own turn.
+        if (inside.has(ppid))
+            continue;
         /**
          * …and reparented to the USER MANAGER counts the same (measured 10.09.2026).
          *
@@ -1632,8 +1854,12 @@ export function scopeOwnerLiveness(unit, io = {}) {
         try {
             parentComm = readFile(path.join('/proc', String(ppid), 'comm')).trim();
         }
-        catch {
+        catch (error) {
             // The parent went between the two reads: it is not supervising anything.
+            // Anything other than «it is gone» is a /proc we could not read — see the
+            // catch above; the same rule, for the same reason.
+            if (!processIsGone(error))
+                sawUnknown = true;
             continue;
         }
         if (parentComm === 'systemd' || parentComm === 'init')

package/dist/session-stall.d.ts

@@ -305,6 +305,31 @@ export declare function readScopeProcesses(unit: string, readFile?: (p: string)
  *    over that a `sh`, and killing the leaf leaves the parent to start another.
  */
 export declare function pickKillCandidate(processes: ScopeProcess[], agentPid?: number | null): KillCandidate | null;
+/**
+ * How many COMMANDS this session has running, counted the way a person counts
+ * them (#431).
+ *
+ * Used on the way out: the runner is about to take the cage down with it, and
+ * the line it writes into the feed has to say how much work that costs. The
+ * number must therefore mean what the sentence says – «commands», not
+ * «processes»: `bash -lc 'docker compose up'` is three or four processes and
+ * exactly one command, and a person who is told «7 processes were stopped»
+ * learns nothing they can act on.
+ *
+ * The exclusions are {@link pickKillCandidate}'s, for the same reasons and with
+ * the same reading of `agentPid`:
+ *
+ *  - **the agent is not a command.** It is the root of the tree, and stopping
+ *    it is what the restart is.
+ *  - **MCP servers and everything under them are not commands.** They are the
+ *    agent's own plumbing; the session did not ask for them and nothing of the
+ *    person's work is lost with them.
+ *
+ * `git` is NOT excluded here, though it is excluded there: that rule exists so
+ * the memory brake does not leave `.git/index.lock` behind, and this function
+ * stops nothing – it counts what is about to go either way.
+ */
+export declare function countRunningCommands(processes: ScopeProcess[], agentPid?: number | null): number;
 /**
  * Is this pid still the process it was when we decided to stop it?
  *

package/dist/session-stall.js

@@ -668,6 +668,90 @@ export function pickKillCandidate(processes, agentPid = null) {
     }
     return best;
 }
+/**
+ * How many COMMANDS this session has running, counted the way a person counts
+ * them (#431).
+ *
+ * Used on the way out: the runner is about to take the cage down with it, and
+ * the line it writes into the feed has to say how much work that costs. The
+ * number must therefore mean what the sentence says – «commands», not
+ * «processes»: `bash -lc 'docker compose up'` is three or four processes and
+ * exactly one command, and a person who is told «7 processes were stopped»
+ * learns nothing they can act on.
+ *
+ * The exclusions are {@link pickKillCandidate}'s, for the same reasons and with
+ * the same reading of `agentPid`:
+ *
+ *  - **the agent is not a command.** It is the root of the tree, and stopping
+ *    it is what the restart is.
+ *  - **MCP servers and everything under them are not commands.** They are the
+ *    agent's own plumbing; the session did not ask for them and nothing of the
+ *    person's work is lost with them.
+ *
+ * `git` is NOT excluded here, though it is excluded there: that rule exists so
+ * the memory brake does not leave `.git/index.lock` behind, and this function
+ * stops nothing – it counts what is about to go either way.
+ */
+export function countRunningCommands(processes, agentPid = null) {
+    if (processes.length === 0)
+        return 0;
+    const byPid = new Map(processes.map((p) => [p.pid, p]));
+    const children = new Map();
+    for (const p of processes) {
+        if (!byPid.has(p.ppid))
+            continue;
+        const list = children.get(p.ppid);
+        if (list)
+            list.push(p.pid);
+        else
+            children.set(p.ppid, [p.pid]);
+    }
+    const roots = processes.filter((p) => !byPid.has(p.ppid)).map((p) => p.pid);
+    /**
+     * The agent, and ONLY the agent, when its pid is known (independent review of
+     * #431).
+     *
+     * `pickKillCandidate` protects every parentless process, and there that is
+     * right: it chooses something to KILL, and a command wrongly spared costs a
+     * retry while the agent wrongly killed costs the session. Counting is the
+     * other way round. A cage has more than one parentless process whenever the
+     * agent left something behind it — `setsid`, `nohup pnpm dev &`, a double
+     * fork: the child stays in the cgroup and is reparented to the user manager,
+     * OUTSIDE the cage. Measured on this machine 16.09.2026: such a command was
+     * counted as zero, so the person was told nothing at all while it was being
+     * stopped — the exact silence this line exists to break (#427).
+     */
+    const excluded = new Set(agentPid === null ? roots : [agentPid]);
+    const spread = (pid) => {
+        for (const child of children.get(pid) ?? []) {
+            if (excluded.has(child))
+                continue;
+            excluded.add(child);
+            spread(child);
+        }
+    };
+    for (const p of processes) {
+        if (!p.mcp)
+            continue;
+        excluded.add(p.pid);
+        // …but never from the agent: its own command line names the MCP config, so
+        // spreading from it would hide every command it ever started.
+        const isAgent = agentPid === null ? roots.includes(p.pid) : p.pid === agentPid;
+        if (!isAgent)
+            spread(p.pid);
+    }
+    let commands = 0;
+    for (const p of processes) {
+        if (excluded.has(p.pid))
+            continue;
+        // Only the top of each surviving subtree: a process whose parent is also a
+        // command is part of that command, not another one.
+        if (byPid.has(p.ppid) && !excluded.has(p.ppid))
+            continue;
+        commands += 1;
+    }
+    return commands;
+}
 /**
  * Is this pid still the process it was when we decided to stop it?
  *

package/dist/supervisor.d.ts

@@ -186,6 +186,19 @@ export interface SupervisorOptions {
      * it never calls it twice at once. Production sweeps for real.
      */
     sweepOrphanSessionScopes?: (liveIds: Iterable<string>) => Promise<string[]>;
+    /**
+     * #431: taking a session's cage down together with its agent. A test has no
+     * systemd to answer, and the daemon must not need one to be testable here.
+     */
+    stopSessionScope?: (unit: string | null) => Promise<boolean>;
+    /** How long those stops are given. The real one is 3 s — no suite waits it out. */
+    cageStopBudgetMs?: number;
+    /**
+     * Which pid in a cage is the agent. Production reads the register the spawn
+     * filled; without the seam every test counted commands through the fallback
+     * branch, i.e. never the one the daemon uses (independent review of #431).
+     */
+    sessionAgentPid?: (id: string) => number | null;
     /**
      * #398 S2: the stall mechanism's four doors to the machine.
      *
@@ -765,6 +778,16 @@ export declare class Supervisor {
      */
     private publishBackgroundHeartbeats;
     private publishHostLoad;
+    /**
+     * Set by {@link shutdown}, and read wherever this supervisor could still be
+     * ASKED to do something after it has let go of everything (#431).
+     *
+     * It exists because the daemon now outlives `shutdown()` by up to three
+     * seconds — the time its cages are given to stop. Until that change every
+     * caller exited in the same tick and «after shutdown» was not a state
+     * anything could be in.
+     */
+    private shuttingDown;
     private onFrame;
     private startSession;
     /**
@@ -1076,6 +1099,26 @@ export declare class Supervisor {
      */
     private armCompactionWatchdog;
     private clearCompactionWatchdog;
+    /**
+     * A card that interrupted a RESTING session has been answered: go back to
+     * rest instead of reporting a turn (#382).
+     *
+     * Which card it was does not matter — a Codex helper's approval, a Claude
+     * background subagent's, an ask either of them parked while the session was
+     * already the person's. What matters is that no turn of this session was
+     * running when the card went out, so there is no turn to go back to and
+     * nothing that would end one: on Codex the helper's own ending is explicitly
+     * not the session's, so «Working» stood until somebody typed.
+     *
+     * Only when the burst is over — both card sets empty — because answering one
+     * of three still leaves the session parked on the other two. The frame
+     * carries the background count like every other status report, so the badge
+     * and the Inbox see «resting, with helpers» rather than «your turn».
+     *
+     * Returns true when it handled the resolution, so the callers' «the human
+     * answered, bill again» branches stay out of it.
+     */
+    private restAfterCard;
     /**
      * Record how many subagents are alive, and say so when it matters (#236).
      *
@@ -1581,8 +1624,49 @@ export declare class Supervisor {
      */
     private sendEvent;
     private reportStatus;
-    /** Graceful daemon shutdown: kill agents, keep sessions resumable server-side. */
-    shutdown(): void;
+    /**
+     * How long the whole fleet of cages is given to stop before this process goes
+     * anyway (#431).
+     *
+     * The bus has been measured at 2.7 s under load and the stops run in
+     * parallel, so three seconds is room for all of them on a bad day. Going over
+     * it costs nothing: `stop` has been ACCEPTED by then, and systemd finishes
+     * the job whether or not anybody is still here to watch. systemd's own
+     * patience with this service is `TimeoutStopSec`, far above this.
+     */
+    private static readonly CAGE_STOP_BUDGET_MS;
+    /**
+     * Graceful daemon shutdown: kill agents, take their cages with them, keep
+     * sessions resumable server-side.
+     *
+     * **Everything that has to survive this process happens BEFORE the first
+     * `await`** — the withdrawn cards, the feed line, and the word to each agent
+     * that it is over (a signal for Codex; for Claude, stdin closed and the SDK's
+     * own `close()`, whose SIGTERM is a timer this process will not live to see —
+     * on a caged machine what actually ends it is the stop below). A caller that
+     * does not wait (the suite does not) gets exactly the shutdown it always got;
+     * what it misses is only the stop of the cgroups. Written this way rather
+     * than as two methods because «kill the agent» and «put its cage out» are one
+     * action, and the shape of the code is what stops them drifting apart again
+     * (грабля §479).
+     *
+     * What the caller owes in return: close the socket between the two halves.
+     * The events above need it open, and the seconds below must not be a window
+     * in which a `session_start` arrives at a supervisor that has already let go
+     * of everything (`index.ts`).
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Put out every cage this daemon was holding, in parallel and on a clock.
+     *
+     * Until 0.65.0 nothing did this: `releaseSessionScope` hangs off the agent
+     * process's `exit`, and on a restart the daemon is gone before that event
+     * fires. What stayed behind was a whole tree — a build, its docker client,
+     * their children — holding the name of a scope systemd will then refuse to
+     * reuse, so the FIRST start of that session after the restart died as
+     * «exited before the session was ready (code 1)» (#431).
+     */
+    private stopCages;
 }
 /**
  * The first message the agent gets.