start-command 0.37.9 → 0.39.0

package/test/regression-231.js

@@ -0,0 +1,298 @@
+/**
+ * Issue #231: executions get caller-chosen names (`--alias`, `--rename`) and
+ * can declare the execution they continue (`--continues`), which `--status`
+ * reports and `--upload-log` follows.
+ */
+const { describe, it, expect } = require('bun:test');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { parseArgs } = require('../src/lib/args-parser');
+const {
+  ExecutionStore,
+  ExecutionRecord,
+} = require('../src/lib/execution-store');
+const {
+  executionAliases,
+  findRecord,
+  nameExecution,
+} = require('../src/lib/execution-identity');
+const {
+  attachIdentity,
+  buildChain,
+  identityTextLines,
+  prepareUploadLog,
+  resolveContinues,
+} = require('../src/lib/execution-chain');
+
+const CLI = path.join(__dirname, '../src/bin/cli.js');
+const A = '23100000-0000-4000-8000-00000000000a';
+const B = '23100000-0000-4000-8000-00000000000b';
+const C = '23100000-0000-4000-8000-00000000000c';
+
+function sandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'start-231-'));
+  const appFolder = path.join(root, 'app');
+  return {
+    root,
+    store: new ExecutionStore({ appFolder }),
+    env: {
+      ...process.env,
+      START_APP_FOLDER: appFolder,
+      START_LOG_DIR: path.join(root, 'logs'),
+      START_DISABLE_AUTO_ISSUE: '1',
+      START_DISABLE_LOG_UPLOAD: '1',
+      START_EXECUTION_ID: '',
+    },
+  };
+}
+
+function run(box, args) {
+  return spawnSync(process.execPath, [CLI, ...args], {
+    env: box.env,
+    encoding: 'utf8',
+    timeout: 20000,
+  });
+}
+
+function record(uuid, options = {}, extra = {}) {
+  const r = new ExecutionRecord({ uuid, command: `cmd-${uuid}`, options });
+  Object.assign(r, extra);
+  return r;
+}
+
+describe('issue #231: execution names', () => {
+  it('resolves uuid, session name, earlier names, then aliases', () => {
+    const records = [
+      record(A, { aliases: [B] }),
+      record(B, { sessionName: 'live' }),
+      record(C, { sessionNameHistory: ['old'], name: 'task' }),
+    ];
+    expect(findRecord(records, B).uuid).toBe(B);
+    expect(findRecord(records, 'live').uuid).toBe(B);
+    expect(findRecord(records, 'old').uuid).toBe(C);
+    expect(findRecord(records, 'task').uuid).toBe(C);
+    expect(findRecord(records, 'missing')).toBeNull();
+    expect(findRecord(records, '')).toBeNull();
+  });
+
+  it('--alias adds a name and refuses one used by another execution', () => {
+    const { store } = sandbox();
+    store.save(record(A, { sessionName: 'screen-a' }));
+    store.save(record(B));
+    const added = nameExecution(store, 'screen-a', 'task-1');
+    expect(added).toEqual({
+      success: true,
+      output: `Aliased execution ${A}\naliases: [${A}, screen-a, task-1]`,
+    });
+    expect(store.get('task-1').uuid).toBe(A);
+    expect(nameExecution(store, A, 'task-1').output).toStartWith(
+      `Unchanged execution ${A}`
+    );
+    expect(nameExecution(store, B, 'task-1')).toEqual({
+      success: false,
+      error: `Name "task-1" already refers to execution ${A}`,
+    });
+    expect(nameExecution(store, B, A).success).toBe(false);
+    expect(nameExecution(store, 'nope', 'x').error).toBe(
+      'No execution found with UUID or session name: nope'
+    );
+    expect(nameExecution(store, A, '-x').success).toBe(false);
+    // The backend session name list is left alone (it drives --cleanup).
+    expect(store.get(A).options.sessionNameHistory).toBeUndefined();
+  });
+
+  it('--rename sets the display name and keeps the old one resolving', () => {
+    const { store } = sandbox();
+    store.save(record(A, { sessionName: 'screen-a' }));
+    expect(nameExecution(store, A, 'first', { rename: true }).output).toBe(
+      `Renamed execution ${A}\naliases: [${A}, screen-a, first]`
+    );
+    nameExecution(store, 'first', 'second', { rename: true });
+    const renamed = store.get('second');
+    expect(renamed.options).toMatchObject({
+      sessionName: 'screen-a',
+      name: 'second',
+      aliases: ['first'],
+    });
+    expect(store.get('first').uuid).toBe(A);
+    expect(store.get('screen-a').uuid).toBe(A);
+    expect(executionAliases(renamed)).toEqual([
+      A,
+      'screen-a',
+      'first',
+      'second',
+    ]);
+  });
+
+  it('a UUID-shaped alias resolves like any other name', () => {
+    const { store } = sandbox();
+    store.save(record(A));
+    expect(nameExecution(store, A, C).success).toBe(true);
+    expect(store.get(C).uuid).toBe(A);
+  });
+
+  it('parses --alias and --rename with their two arguments', () => {
+    expect(parseArgs(['--alias', A, 'task']).wrapperOptions).toMatchObject({
+      alias: A,
+      newName: 'task',
+    });
+    expect(parseArgs(['--rename', A, 'task']).wrapperOptions).toMatchObject({
+      rename: A,
+      newName: 'task',
+    });
+    expect(() => parseArgs(['--alias', A])).toThrow(
+      'Option --alias requires a UUID or session name and a new name'
+    );
+    expect(() => parseArgs(['--rename', A, '--status'])).toThrow(
+      'Option --rename requires a UUID or session name and a new name'
+    );
+    expect(() => parseArgs(['--alias', A, 'x', '--status', A])).toThrow(
+      /Cannot combine .* --alias, or --rename in the same invocation/
+    );
+  });
+});
+
+describe('issue #231: continuation chains', () => {
+  const chainRecords = () => [
+    record(A, {}, { startTime: '2026-01-01T00:00:00.000Z' }),
+    record(B, {}, { continues: A, startTime: '2026-01-02T00:00:00.000Z' }),
+    record(C, {}, { continues: B, startTime: '2026-01-03T00:00:00.000Z' }),
+  ];
+
+  it('builds the chain from any member, oldest first', () => {
+    const records = chainRecords();
+    for (const member of records) {
+      expect(buildChain(records, member).map((r) => r.uuid)).toEqual([A, B, C]);
+    }
+  });
+
+  it('stops at a cycle', () => {
+    const records = [
+      record(A, {}, { continues: B }),
+      record(B, {}, { continues: A }),
+    ];
+    expect(buildChain(records, records[0]).map((r) => r.uuid)).toEqual([B, A]);
+  });
+
+  it('resolves --continues by any name and refuses unknown or itself', () => {
+    const { store } = sandbox();
+    store.save(record(A, { sessionName: 'first' }));
+    expect(resolveContinues(store, 'first', B)).toBe(A);
+    expect(() => resolveContinues(store, 'nope', B)).toThrow(
+      'No execution found with UUID or session name: nope'
+    );
+    expect(() => resolveContinues(store, A, A)).toThrow(
+      `Execution ${A} cannot continue itself`
+    );
+    expect(() => resolveContinues(null, A, B)).toThrow(
+      '--continues requires execution tracking.'
+    );
+  });
+
+  it('--status reports aliases and the chain right after uuid', () => {
+    const { store } = sandbox();
+    chainRecords().forEach((r) => store.save(r));
+    nameExecution(store, B, 'task');
+    const obj = attachIdentity(store.get(B), store).toObject();
+    expect(Object.keys(obj).slice(0, 3)).toEqual(['uuid', 'aliases', 'chain']);
+    expect(obj.aliases).toEqual([B, 'task']);
+    expect(obj.chain).toEqual([A, B, C]);
+    expect(obj.continues).toBe(A);
+    expect(identityTextLines(obj)).toEqual([
+      `Aliases:           ${B}, task`,
+      `Continues:         ${A}`,
+      `Chain:             ${A} -> ${B} -> ${C}`,
+    ]);
+    // A record without names or a chain is reported unchanged.
+    const plain = record(C);
+    expect(attachIdentity(plain, null)).toBe(plain);
+  });
+
+  it('--upload-log joins the chain logs, oldest first', () => {
+    const { store, root } = sandbox();
+    chainRecords().forEach((r, i) => {
+      r.logPath = path.join(root, `${i}.log`);
+      fs.writeFileSync(r.logPath, `log-${i}\n`);
+      store.save(r);
+    });
+    const single = record('23100000-0000-4000-8000-0000000000dd');
+    single.logPath = '/x.log';
+    store.save(single);
+    expect(prepareUploadLog(store, single).path).toBe('/x.log');
+
+    const prepared = prepareUploadLog(store, store.get(B));
+    const text = fs.readFileSync(prepared.path, 'utf8');
+    expect(text.indexOf('log-0')).toBeLessThan(text.indexOf('log-1'));
+    expect(text.indexOf('log-1')).toBeLessThan(text.indexOf('log-2'));
+    expect(text.split('"event":"continuation"').length - 1).toBe(3);
+    expect(text).toContain(`"uuid":"${C}","chainIndex":3,"chainLength":3`);
+    prepared.cleanup();
+    expect(fs.existsSync(prepared.path)).toBe(false);
+  });
+
+  it('parses --continues and keeps it to launches', () => {
+    expect(
+      parseArgs(['--continues', A, '--', 'echo']).wrapperOptions.continues
+    ).toBe(A);
+    expect(
+      parseArgs([`--continues=${A}`, '--', 'echo']).wrapperOptions.continues
+    ).toBe(A);
+    expect(() => parseArgs(['--continues', '--', 'echo'])).toThrow(
+      'Option --continues requires a UUID or session name argument'
+    );
+    expect(() => parseArgs(['--status', A, '--continues', B])).toThrow(
+      '--continues option is only valid when launching a command'
+    );
+  });
+});
+
+describe('issue #231: CLI flow', () => {
+  if (process.platform === 'win32') {
+    return;
+  }
+
+  it('aliases, renames and chains executions end to end', () => {
+    const box = sandbox();
+    expect(run(box, ['--session-id', A, '--', 'echo', 'one']).status).toBe(0);
+    const alias = run(box, ['--alias', A, 'nightly']);
+    expect(alias.status).toBe(0);
+    expect(alias.stdout).toContain(`Aliased execution ${A}`);
+    const rename = run(box, ['--rename', 'nightly', 'nightly-1']);
+    expect(rename.stdout).toContain(`Renamed execution ${A}`);
+
+    const second = run(box, [
+      '--session-id',
+      B,
+      '--continues',
+      'nightly-1',
+      '--',
+      'echo',
+      'two',
+    ]);
+    expect(second.status).toBe(0);
+
+    const status = run(box, [
+      '--status',
+      'nightly-1',
+      '--output-format',
+      'json',
+    ]);
+    const obj = JSON.parse(status.stdout);
+    expect(obj.uuid).toBe(A);
+    expect(obj.aliases).toEqual([A, 'nightly', 'nightly-1']);
+    expect(obj.chain).toEqual([A, B]);
+
+    const text = run(box, ['--status', B, '--output-format', 'text']);
+    expect(text.stdout).toContain(`Continues:         ${A}`);
+    expect(text.stdout).toContain(`Chain:             ${A} -> ${B}`);
+
+    const missing = run(box, ['--continues', 'nope', '--', 'echo', 'x']);
+    expect(missing.status).toBe(1);
+    expect(missing.stderr).toContain(
+      'No execution found with UUID or session name: nope'
+    );
+    expect(missing.stdout).not.toContain('x\n');
+  });
+});

package/test/regression-236.js

@@ -0,0 +1,250 @@
+// Own the snapshot lock when run without the default preloads.
+require('./setup/private-snapshot-lock');
+const { it, expect } = require('bun:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { parseArgs } = require('../src/lib/args-parser');
+const {
+  resolveResourceOptions,
+} = require('../src/lib/docker-resource-options');
+const {
+  buildDockerRuntimeArgs,
+  buildDockerRuntimeMetadata,
+} = require('../src/lib/docker-runtime-args');
+const {
+  ExecutionRecord,
+  ExecutionStore,
+} = require('../src/lib/execution-store');
+const { formatRecord } = require('../src/lib/status-formatter');
+const { resumeExecution } = require('../src/lib/execution-resume');
+
+it('parses the reported command and forwards both limits to Docker', () => {
+  for (const flag of [
+    ['--memory-reservation', '64m'],
+    ['--memory-reservation=64m'],
+  ]) {
+    const options = parseArgs([
+      '--isolated',
+      'docker',
+      '--image',
+      'alpine:3.20',
+      '--memory',
+      '256m',
+      ...flag,
+      '--',
+      'echo',
+      'hi',
+    ]).wrapperOptions;
+    expect(options.memoryReservation).toBe('64m');
+    const resolved = resolveResourceOptions(options);
+    const argv = buildDockerRuntimeArgs(resolved);
+    expect(argv).toContain('--memory=268435456');
+    expect(argv).toContain('--memory-reservation=67108864');
+    const metadata = buildDockerRuntimeMetadata({ ...options, ...resolved });
+    const record = ExecutionRecord.fromObject(
+      new ExecutionRecord({ command: 'echo hi', options: metadata }).toObject()
+    );
+    expect(record.options.resourceLimitSpecs.memoryReservation).toBe('64m');
+    expect(record.options.resolvedLimits.memoryReservation).toBe(67108864);
+    for (const format of ['json', 'text', 'links-notation']) {
+      expect(formatRecord(record, format)).toContain('memoryReservation');
+      expect(formatRecord(record, format)).toContain('67108864');
+    }
+  }
+});
+
+it('resolves reservation percentages from daemon RAM once, including ranges', () => {
+  let calls = 0;
+  const resolved = resolveResourceOptions(
+    { memory: '50%', memoryReservation: '10%-20%' },
+    (_, argv) => {
+      calls++;
+      expect(argv[0]).toBe('info');
+      return {
+        success: true,
+        stdout: JSON.stringify({ MemTotal: 10 * 1024 ** 3, NCPU: 8 }),
+      };
+    },
+    () => 0.5
+  );
+  expect(calls).toBe(1);
+  expect(resolved.resolvedLimits.memoryReservation).toBe(1610612736);
+  expect(resolved.resourceLimitSpecs.memoryReservation).toBe('10%-20%');
+  expect(
+    resolveResourceOptions({ resourceLimits: resolved.resourceLimits }, () => {
+      throw Error('must preserve resolved limits');
+    }).resourceLimits
+  ).toEqual(resolved.resourceLimits);
+});
+
+it('rejects equal or larger reservations against new and inherited hard caps', () => {
+  for (const options of [
+    { memory: '256m', memoryReservation: '512m' },
+    { memory: '256m', memoryReservation: '256m' },
+    { memoryReservation: '512m', resourceLimits: ['--memory=256m'] },
+    {
+      memory: '32m',
+      resourceLimits: ['--memory=256m', '--memory-reservation=64m'],
+    },
+  ]) {
+    expect(() => resolveResourceOptions(options)).toThrow(
+      'memory-reservation must be less than memory'
+    );
+  }
+  expect(
+    resolveResourceOptions({ memoryReservation: '64m' }).resourceLimits
+  ).toEqual(['--memory-reservation=67108864']);
+});
+
+it('validates reservation syntax, missing values and Docker isolation', () => {
+  for (const value of ['0m', '0%', '101%', '10watts', '20%-10%', '']) {
+    expect(() =>
+      parseArgs([
+        '--isolated',
+        'docker',
+        `--memory-reservation=${value}`,
+        '--',
+        'true',
+      ])
+    ).toThrow();
+  }
+  expect(() =>
+    parseArgs(['--isolated', 'docker', '--memory-reservation'])
+  ).toThrow();
+  expect(() => parseArgs(['--memory-reservation=64m', '--', 'true'])).toThrow(
+    'Resource options require Docker'
+  );
+});
+
+it('forwards reservations through a nested Docker isolation level', () => {
+  const options = parseArgs([
+    '--isolated',
+    'screen docker',
+    '--memory',
+    '256m',
+    '--memory-reservation',
+    '64m',
+    '--',
+    'work',
+  ]).wrapperOptions;
+  expect(
+    require('../src/lib/command-builder').buildNextLevelCommand(options, 'work')
+  ).toContain('--memory-reservation 64m');
+});
+
+for (const mode of ['start', 'snapshot', 'missing', 'override', 'invalid']) {
+  it(`preserves or overrides the reservation on ${mode} resume`, async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-236-'));
+    try {
+      const store = new ExecutionStore({ appFolder: dir, useLinks: false });
+      const resolved = resolveResourceOptions({
+        memory: '256m',
+        memoryReservation: '64m',
+      });
+      const record = new ExecutionRecord({
+        command: 'work',
+        status: 'executed',
+        logPath: path.join(dir, 'run.log'),
+        options: {
+          isolated: 'docker',
+          isolationMode: 'detached',
+          sessionName: 'task',
+          image: 'alpine',
+          ...resolved,
+        },
+      });
+      store.save(record);
+      const calls = [];
+      const runner = (_, args) => {
+        calls.push(args);
+        if (args[0] === 'info') {
+          return {
+            success: true,
+            stdout: JSON.stringify({
+              MemTotal: 1024 ** 3,
+              NCPU: 4,
+              DockerRootDir: os.tmpdir(),
+            }),
+          };
+        }
+        if (args.includes('--size')) {
+          return { success: true, stdout: '1024' };
+        }
+        if (args[0] === 'inspect') {
+          return {
+            success: true,
+            stdout: JSON.stringify({
+              Memory: 268435456,
+              MemorySwap: 268435456,
+              MemoryReservation: 67108864,
+            }),
+          };
+        }
+        return { success: true, stdout: 'id' };
+      };
+      const result = await resumeExecution(store, record.uuid, {
+        command: mode === 'snapshot' ? 'new' : null,
+        resourceOptions:
+          mode === 'override'
+            ? { memoryReservation: '32m' }
+            : mode === 'invalid'
+              ? { memory: '32m' }
+              : {},
+        runIsolated: async (_backend, _command, options) => {
+          calls.push(['run', ...options.resourceLimits]);
+          return { success: true };
+        },
+        snapshotOptions: { freeBytes: () => 100 * 1024 ** 3 },
+        runner,
+        probe: () => ({
+          alive: false,
+          state: mode === 'missing' ? 'missing' : 'stopped',
+        }),
+        startWatcher: () => true,
+      });
+      expect(result.success).toBe(mode !== 'invalid');
+      if (mode === 'invalid') {
+        expect(result.error).toContain(
+          'memory-reservation must be less than memory'
+        );
+        expect(
+          calls.some((a) => ['start', 'run', 'update', 'commit'].includes(a[0]))
+        ).toBe(false);
+      } else {
+        const current = store.get(record.uuid);
+        const bytes = mode === 'override' ? 33554432 : 67108864;
+        expect(current.options.resolvedLimits.memoryReservation).toBe(bytes);
+        expect(current.options.resourceLimitSpecs.memoryReservation).toBe(
+          mode === 'override' ? '32m' : '64m'
+        );
+        if (mode === 'override') {
+          expect(calls.find((a) => a[0] === 'update')).toContain(
+            `--memory-reservation=${bytes}`
+          );
+          expect(calls.findIndex((a) => a[0] === 'update')).toBeLessThan(
+            calls.findIndex((a) => a[0] === 'start')
+          );
+        }
+        if (mode === 'snapshot' || mode === 'missing') {
+          const limits = calls.find((a) => a[0] === 'run');
+          expect(
+            limits.some((s) => /^--memory-reservation=(64m|67108864)$/.test(s))
+          ).toBe(true);
+        }
+      }
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+}
+
+it('refuses reservation overrides when resuming a non-Docker execution', () => {
+  expect(() =>
+    require('../src/lib/resume-resources').prepareResumeResources(
+      { options: { isolated: 'screen' } },
+      { state: 'stopped' },
+      { memoryReservation: '64m' }
+    )
+  ).toThrow('Resource overrides require a Docker execution');
+});

package/test/regression-238.js

@@ -0,0 +1,129 @@
+const { describe, it, expect } = require('bun:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  buildCgroupSamplerStartSnippet,
+  buildCgroupSamplerStopSnippet,
+  buildCgroupMemoryLogSnippet,
+} = require('../src/lib/cgroup-memory');
+
+function sample(mode, interval, clockStep = '5') {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sampler-238-'));
+  try {
+    const script = path.join(dir, 'sample.sh');
+    fs.writeFileSync(
+      script,
+      [
+        buildCgroupSamplerStartSnippet("task '238'"),
+        'wait "$__start_command_cgroup_sampler"',
+        mode === 'final'
+          ? 'printf "oom 3\\noom_kill 3\\n" > "$START_COMMAND_CGROUP_ROOT/docker/238abc/memory.events"'
+          : ':',
+        buildCgroupSamplerStopSnippet(),
+        'printf "sample=%s\\n" "$__start_command_cgroup"',
+        buildCgroupMemoryLogSnippet('"$TMPDIR/memory.log"'),
+        'cat "$TMPDIR/memory.log" "$TMPDIR/calls"',
+        'sed "s/^/sleep=/" "$TMPDIR/sleeps"',
+        // Stop must remove every temporary sample file.
+        'for file in "$TMPDIR"/start-command-cgroup*; do [ ! -e "$file" ] || exit 1; done',
+      ].join('; ')
+    );
+    const env = { ...process.env, START_SAMPLER_CLOCK_STEP: clockStep };
+    delete env.START_COMMAND_CGROUP_SAMPLE_INTERVAL_SECONDS;
+    if (interval !== undefined) {
+      env.START_COMMAND_CGROUP_SAMPLE_INTERVAL_SECONDS = interval;
+    }
+    const result = spawnSync(
+      '/bin/sh',
+      [
+        path.resolve(
+          __dirname,
+          '../../experiments/issue-238-cgroup-polling.sh'
+        ),
+        mode,
+        script,
+      ],
+      { encoding: 'utf8', env }
+    );
+    expect(result.status).toBe(0);
+    return result.stdout;
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+const count = (output, text) =>
+  output.split('\n').filter((line) => line.includes(text)).length;
+const posix = process.platform === 'win32' ? describe.skip : describe;
+
+posix('issue #238: bounded Docker cgroup sampling', () => {
+  it('defaults to five seconds and inspects local liveness only after removal', () => {
+    const output = sample('local');
+    expect(count(output, 'sleep=5')).toBe(3);
+    expect(count(output, '{{.State.Running}}')).toBe(1);
+    expect(count(output, '{{.HostConfig.CgroupnsMode}}')).toBe(1);
+    // A readable local cgroup never starts a remote exec, even after removal
+    // (issue #242): the liveness probe ends the loop instead.
+    expect(count(output, "task '238' sh -c")).toBe(0);
+  });
+
+  it('honors an override in the watcher environment and caches remote namespace', () => {
+    const output = sample('remote', '2');
+    expect(count(output, 'sleep=2')).toBe(3);
+    expect(count(output, '{{.HostConfig.CgroupnsMode}}')).toBe(1);
+    // One long-lived exec streams every round; liveness is probed once, after
+    // the stream ends (issue #242).
+    expect(count(output, '{{.State.Running}}')).toBe(1);
+    expect(count(output, "task '238' sh -c")).toBe(1);
+    expect(output).toContain(
+      'memory.max=67108864 memory.peak=33554432 oom=1 oom_kill=3'
+    );
+  });
+
+  it('rejects zero, negative, fractional, malformed and unsafe intervals', () => {
+    for (const interval of [
+      '',
+      '0',
+      '000',
+      '-1',
+      '0.5',
+      'nope',
+      '1; exit 7',
+      '99999999999999999999999999',
+    ]) {
+      expect(count(sample('remote', interval), 'sleep=5')).toBe(3);
+    }
+  });
+
+  it('keeps unavailable diagnostics and the last sample across remote outages', () => {
+    for (const mode of ['shared', 'no-shell', 'outage']) {
+      const output = sample(mode);
+      expect(count(output, '{{.HostConfig.CgroupnsMode}}')).toBe(1);
+      // A shared namespace or a missing shell ends sampling at once; an outage
+      // falls back to per-round execs, each followed by a liveness probe.
+      expect(count(output, '{{.State.Running}}')).toBe(
+        mode === 'outage' ? 4 : 0
+      );
+      expect(count(output, "task '238' sh -c")).toBe(
+        { shared: 0, 'no-shell': 1, outage: 4 }[mode]
+      );
+      if (mode === 'outage') {
+        expect(output).toContain('sample=67108864 33554432 1 3 0 100');
+      } else {
+        expect(output).toContain('Memory:     unavailable');
+        expect(output).toContain(
+          mode === 'shared' ? 'namespace=host' : 'sh: not found'
+        );
+      }
+    }
+  });
+
+  it('preserves a final read without treating a five-second counter gap as recent OOM', () => {
+    expect(sample('final')).toContain('sample=67108864 33554432 3 3 0 115');
+    expect(sample('final', '1', '1')).toContain(
+      'sample=67108864 33554432 3 3 103 103'
+    );
+  });
+});