start-command 0.37.0 → 0.37.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # start-command
 
+## 0.37.1
+
+### Patch Changes
+
+- c67c92f: Observe Docker CPU limits applied after launch, restore the remembered base on lift and resume, and recover CPU penalty monitors after crashes, zombie/reused-PID locks and transient tick failures.
+
 ## 0.37.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.37.0",
+  "version": "0.37.1",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/src/lib/cpu-penalty-monitor.js

@@ -2,10 +2,20 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
-const { initialState, evaluate } = require('./cpu-penalty');
+const {
+  initialState,
+  evaluate,
+  observeBase,
+  transitionLog,
+} = require('./cpu-penalty');
 const { LockManager } = require('./store-lock');
 const { shellQuote } = require('./isolation-log-utils');
-const { cpuCount, cpuUpdateArgs } = require('./docker-resource-limits');
+const {
+  cpuCount,
+  cpuUpdateArgs,
+  normalizeResourceLimits,
+  readDockerResourceLimits,
+} = require('./docker-resource-limits');
 function statePath(record) {
   return `${record.logPath}.cpu-penalty.json`;
 }
@@ -40,9 +50,21 @@ function publicState(state) {
 }
 function run(command, args) {
   const result = spawnSync(command, args, { encoding: 'utf8' });
-  return { success: result.status === 0, stdout: result.stdout || '' };
+  return {
+    success: result.status === 0,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+  };
 }
-async function monitor(uuid, name, attemptNumber, standalone) {
+async function monitor(
+  uuid,
+  name,
+  attemptNumber,
+  standalone,
+  dependencies = {}
+) {
+  const filesystem = dependencies.fs || fs;
+  const runner = dependencies.run || run;
   const { ExecutionStore } = require('./execution-store');
   const store = uuid
     ? new ExecutionStore(
@@ -60,36 +82,40 @@ async function monitor(uuid, name, attemptNumber, standalone) {
     return;
   }
   const config = record.options.cpuPenaltyConfig;
-  const lock = new LockManager(`${statePath(record)}.lock`);
+  if ((record.attempt?.number || 1) !== Number(attemptNumber)) {
+    return;
+  }
+  const lock = new LockManager(`${statePath(record)}.lock`, filesystem, true);
   if (!lock.acquire(100)) {
     return;
   }
   const docker = require('./docker-cleanup').getDockerCommand();
-  const baseFlags =
-    record.options.baseResourceLimits || record.options.resourceLimits || [];
+  let baseFlags = normalizeResourceLimits(
+    record.options.baseResourceLimits || record.options.resourceLimits
+  );
   const baseCpus = cpuCount(baseFlags);
   let state = initialState(baseCpus, Date.now(), readState(record));
   const interval = Math.min(
     30000,
     Math.max(50, Math.min(config.triggerWindowMs, config.releaseWindowMs) / 8)
   );
-  const publish = () => {
+  const publish = (value = state) => {
     const file = statePath(record),
       tmp = `${file}.${process.pid}.tmp`;
     try {
-      fs.writeFileSync(
+      filesystem.writeFileSync(
         tmp,
         JSON.stringify({
-          ...publicState(state),
+          ...publicState(value),
           containerName: name,
           attemptNumber: Number(attemptNumber),
           updatedAt: Date.now(),
         })
       );
-      fs.renameSync(tmp, file);
+      filesystem.renameSync(tmp, file);
     } finally {
       try {
-        fs.unlinkSync(tmp);
+        filesystem.unlinkSync(tmp);
       } catch {
         /* Optional diagnostics are best effort. */
       }
@@ -97,95 +123,188 @@ async function monitor(uuid, name, attemptNumber, standalone) {
   };
   const log = (text) => {
     try {
-      fs.appendFileSync(record.logPath, `${text}\n`);
+      filesystem.appendFileSync(record.logPath, `${text}\n`);
     } catch {
       /* Optional diagnostics are best effort. */
     }
   };
-  const started = Date.now();
+  const debug = (error) => {
+    if (process.env.START_DEBUG === '1') {
+      const message = `[DEBUG] CPU monitor: ${error.stack || error}`;
+      console.error(message);
+      log(message);
+    }
+  };
+  let stopping = false,
+    wake;
+  const stop = () => {
+    stopping = true;
+    wake?.();
+  };
+  process.on('SIGTERM', stop);
+  process.on('SIGINT', stop);
   try {
-    publish();
-    while (true) {
-      const current = store ? store.get(uuid) : record;
-      if (
-        !current ||
-        current.options.sessionName !== name ||
-        (current.attempt?.number || 1) !== Number(attemptNumber)
-      ) {
-        break;
-      }
-      const live = run(docker, ['inspect', '-f', '{{.State.Running}}', name]);
-      if (live.success && live.stdout.trim() === 'false') {
-        break;
-      }
-      if (!live.success && Date.now() - started > 30000) {
-        break;
-      }
-      const info = run(docker, ['info', '--format', '{{json .}}']);
-      const stats = run(docker, [
-        'stats',
-        '--no-stream',
-        '--format',
-        '{{json .}}',
-      ]);
-      let daemonCpus = NaN,
-        cores = NaN;
+    while (!stopping) {
       try {
-        if (info.success) {
-          daemonCpus = JSON.parse(info.stdout).NCPU;
+        const current = store ? store.get(uuid) : record;
+        if (
+          !current ||
+          current.options.sessionName !== name ||
+          (current.attempt?.number || 1) !== Number(attemptNumber)
+        ) {
+          break;
+        }
+        const live = runner(docker, [
+          'inspect',
+          '-f',
+          '{{.State.Running}}',
+          name,
+        ]);
+        if (live.success && live.stdout.trim() === 'false') {
+          break;
+        }
+        if (
+          !live.success &&
+          /No such (object|container)/i.test(live.stderr || '')
+        ) {
+          break;
+        }
+        const observed = readDockerResourceLimits(name, runner);
+        if (observed !== null) {
+          baseFlags = observed;
+          state = observeBase(state, cpuCount(observed), Date.now());
         }
-        if (stats.success) {
-          const row = stats.stdout
-            .trim()
-            .split('\n')
-            .map((s) => JSON.parse(s))
-            .find((s) => s.Name === name);
-          if (row && /^\d+(?:\.\d+)?%$/.test(row.CPUPerc)) {
-            cores = Number(row.CPUPerc.slice(0, -1)) / 100;
+        const info = runner(docker, ['info', '--format', '{{json .}}']);
+        const stats = runner(docker, [
+          'stats',
+          '--no-stream',
+          '--format',
+          '{{json .}}',
+        ]);
+        let daemonCpus = NaN,
+          cores = NaN;
+        try {
+          if (info.success) {
+            daemonCpus = JSON.parse(info.stdout).NCPU;
+          }
+          if (stats.success && live.success && observed !== null) {
+            const row = stats.stdout
+              .trim()
+              .split('\n')
+              .map((s) => JSON.parse(s))
+              .find((s) => s.Name === name);
+            if (row && /^\d+(?:\.\d+)?%$/.test(row.CPUPerc)) {
+              cores = Number(row.CPUPerc.slice(0, -1)) / 100;
+            }
           }
+        } catch (error) {
+          debug(error);
         }
-      } catch {
-        /* Optional diagnostics are best effort. */
+        debug(
+          `sample: phase=${state.phase} base=${state.baseCpus} limit=${state.limitCpus} cores=${cores} daemon=${daemonCpus}`
+        );
+        const decision = evaluate(
+          state,
+          {
+            now: Date.now(),
+            cores,
+            daemonCpus,
+            maxGapMs: Math.max(5000, interval * 3),
+          },
+          config
+        );
+        if (decision.action) {
+          const action = decision.action;
+          // Persist the base and intent before applying a cap. If this fails,
+          // leave Docker alone; a killed monitor can always recover its base.
+          if (action.kind === 'apply') {
+            publish(decision.state);
+          }
+          const update = runner(docker, [
+            'update',
+            ...cpuUpdateArgs(baseFlags, action.cpus),
+            name,
+          ]);
+          if (update.success) {
+            state = decision.state;
+            log(transitionLog(action, config));
+          } else {
+            debug(update.stderr || 'docker update failed');
+            state = {
+              ...decision.state,
+              phase: state.phase,
+              since: state.since,
+              limitCpus: state.limitCpus,
+              penaltyCount: state.penaltyCount,
+              samples: [],
+            };
+          }
+        } else {
+          state = decision.state;
+        }
+        publish();
+      } catch (error) {
+        state.samples = [];
+        debug(`tick failed: ${error.stack || error}`);
       }
-      const decision = evaluate(
-        state,
-        {
-          now: Date.now(),
-          cores,
-          daemonCpus,
-          maxGapMs: Math.max(5000, interval * 3),
-        },
-        config
-      );
-      if (decision.action) {
-        const action = decision.action;
-        const update = run(docker, [
-          'update',
-          ...cpuUpdateArgs(baseFlags, action.cpus),
+      await new Promise((resolve) => {
+        const timer = globalThis.setTimeout(resolve, interval);
+        wake = () => {
+          globalThis.clearTimeout(timer);
+          resolve();
+        };
+        if (stopping) {
+          wake();
+        }
+      });
+    }
+  } finally {
+    try {
+      const current = store ? store.get(uuid) : record;
+      if (
+        state.phase === 'penalized' &&
+        current?.options.sessionName === name &&
+        (current.attempt?.number || 1) === Number(attemptNumber)
+      ) {
+        const live = runner(docker, [
+          'inspect',
+          '-f',
+          '{{.State.Running}}',
           name,
         ]);
-        if (update.success) {
-          state = decision.state;
-          log(
-            `[start] CPU penalty ${action.kind === 'apply' ? 'applied' : 'lifted'}: ${action.cpus} CPUs (${action.average === null || action.average === undefined ? 'capacity changed' : `${action.average.toFixed(2)} of ${action.capacity} CPUs`})`
-          );
-        } else {
-          state = {
-            ...decision.state,
-            phase: state.phase,
-            since: state.since,
-            limitCpus: state.limitCpus,
-            penaltyCount: state.penaltyCount,
-            samples: [],
-          };
+        const observed = readDockerResourceLimits(name, runner);
+        const info = runner(docker, ['info', '--format', '{{json .}}']);
+        const capacity = info.success ? JSON.parse(info.stdout).NCPU : NaN;
+        if (
+          live.success &&
+          live.stdout.trim() === 'true' &&
+          observed !== null &&
+          cpuCount(observed) === state.limitCpus &&
+          capacity > 0
+        ) {
+          const cpus = Math.min(state.baseCpus || capacity, capacity);
+          const update = runner(docker, [
+            'update',
+            ...cpuUpdateArgs(observed, cpus),
+            name,
+          ]);
+          if (update.success) {
+            state = {
+              ...state,
+              phase: 'observing',
+              limitCpus: cpus,
+              since: Date.now(),
+            };
+            log(`[start] CPU penalty lifted: ${cpus} CPUs (monitor stopped)`);
+            publish();
+          }
         }
-      } else {
-        state = decision.state;
       }
-      publish();
-      await new Promise((resolve) => globalThis.setTimeout(resolve, interval));
+    } catch (error) {
+      debug(error);
     }
-  } finally {
+    process.off('SIGTERM', stop);
+    process.off('SIGINT', stop);
     lock.release();
   }
 }
@@ -204,7 +323,9 @@ function startSnippet(uuid, name, attempt = 1, options = null) {
   if (!uuid && !standalone) {
     return '';
   }
-  return `${shellQuote(process.execPath)} ${shellQuote(__filename)} ${shellQuote(uuid || '')} ${shellQuote(name)} ${Number(attempt)} ${shellQuote(standalone || '')} >/dev/null 2>&1 & __start_cpu_monitor=$!`;
+  const command = `${shellQuote(process.execPath)} ${shellQuote(__filename)} ${shellQuote(uuid || '')} ${shellQuote(name)} ${Number(attempt)} ${shellQuote(standalone || '')}`;
+  // wait reaps a crashed child even in containers whose PID 1 never reaps.
+  return `( __start_cpu_child=; trap 'if [ -n "$__start_cpu_child" ]; then kill "$__start_cpu_child" 2>/dev/null; wait "$__start_cpu_child" 2>/dev/null; fi; exit 0' TERM INT HUP; while :; do ${command} >/dev/null 2>&1 & __start_cpu_child=$!; wait "$__start_cpu_child"; __start_cpu_code=$?; [ "$__start_cpu_code" -eq 0 ] && break; sleep 1 & __start_cpu_child=$!; wait "$__start_cpu_child"; done ) & __start_cpu_monitor=$!`;
 }
 function stopSnippet() {
   return 'if [ -n "$__start_cpu_monitor" ]; then kill "$__start_cpu_monitor" 2>/dev/null; wait "$__start_cpu_monitor" 2>/dev/null; fi';
@@ -219,6 +340,7 @@ module.exports = {
 };
 if (require.main === module) {
   monitor(...process.argv.slice(2)).catch((error) => {
+    process.exitCode = 1;
     if (process.env.START_DEBUG === '1') {
       console.error(`[DEBUG] CPU monitor: ${error.stack}`);
     }

package/src/lib/cpu-penalty.js

@@ -70,10 +70,13 @@ function validate(options) {
   options.cpuPenaltyConfig = { ...DEFAULTS, ...options.cpuPenaltyConfig };
 }
 function initialState(baseCpus = null, now = Date.now(), saved = null) {
+  baseCpus =
+    saved && Object.hasOwn(saved, 'baseCpus') ? saved.baseCpus : baseCpus;
   return {
     phase: saved?.phase === 'penalized' ? 'penalized' : 'observing',
     since: saved?.phase === 'penalized' ? saved.since : now,
-    limitCpus: saved?.phase === 'penalized' ? saved.limitCpus : baseCpus,
+    limitCpus:
+      saved && Object.hasOwn(saved, 'limitCpus') ? saved.limitCpus : baseCpus,
     baseCpus,
     penaltyCount: saved?.penaltyCount || 0,
     penalizedMs: saved?.penalizedMs || 0,
@@ -82,6 +85,30 @@ function initialState(baseCpus = null, now = Date.now(), saved = null) {
     capacity: null,
   };
 }
+// A quota different from our cap is a supervisor override, not our penalty.
+function observeBase(state, baseCpus, now) {
+  if (baseCpus === state.limitCpus) {
+    return state;
+  }
+  return {
+    ...state,
+    phase: 'observing',
+    baseCpus,
+    limitCpus: baseCpus,
+    since: now,
+    samples: [],
+  };
+}
+function transitionLog(action, config) {
+  const applying = action.kind === 'apply';
+  const window = applying ? config.triggerWindowMs : config.releaseWindowMs;
+  const duration = window % 60000 === 0 ? `${window / 60000}m` : `${window}ms`;
+  const measured =
+    action.average === null || action.average === undefined
+      ? 'capacity changed'
+      : `${action.average.toFixed(2)} of ${applying ? action.capacity : config.cpus} CPUs for ${duration}`;
+  return `[start] CPU penalty ${applying ? 'applied' : 'lifted'}: ${action.cpus} CPUs (${measured})`;
+}
 function average(samples, now, window) {
   const start = now - window;
   if (
@@ -170,6 +197,8 @@ module.exports = {
   validate,
   duration,
   initialState,
+  observeBase,
+  transitionLog,
   average,
   evaluate,
 };

package/src/lib/resume-resources.js

@@ -7,13 +7,23 @@ const {
 const { resolveResourceOptions } = require('./docker-resource-options');
 
 // Temporary penalty quotas must never become a resumed execution's base quota.
-function restoreBaseCpu(limits, options) {
+function restoreBaseCpu(limits, options, saved = null, inspected = false) {
   if (!options.cpuPenaltyConfig) {
     return limits;
   }
-  const base = normalizeResourceLimits(
+  if (
+    saved &&
+    inspected &&
+    !(saved.phase === 'penalized' && cpuCount(limits) === saved.limitCpus)
+  ) {
+    return limits;
+  }
+  let base = normalizeResourceLimits(
     options.baseResourceLimits || options.resourceLimits
   );
+  if (saved && Object.hasOwn(saved, 'baseCpus')) {
+    base = saved.baseCpus > 0 ? withCpuLimit(limits, saved.baseCpus) : [];
+  }
   return [
     ...limits.filter((s) => !/^--(?:cpus|cpu-quota|cpu-period)=/.test(s)),
     ...base.filter((s) => /^--(?:cpus|cpu-quota|cpu-period)=/.test(s)),
@@ -38,7 +48,9 @@ function prepareResumeResources(record, probe, overrides, runner, random) {
       : null;
   const base = restoreBaseCpu(
     normalizeResourceLimits(live || options.resourceLimits),
-    options
+    options,
+    require('./cpu-penalty-monitor').readState(record),
+    live !== null
   );
   const oldMemory = base.find((s) => s.startsWith('--memory='))?.slice(9);
   const result = resolveResourceOptions(

package/src/lib/store-lock.js

@@ -7,11 +7,13 @@ const LOCK_STALE_MS = 60000;
 const MALFORMED_LOCK_GRACE_MS = 3000;
 
 class LockManager {
-  constructor(lockFilePath, filesystem = fs) {
+  constructor(lockFilePath, filesystem = fs, monitorOwner = false) {
     this.lockFilePath = lockFilePath;
     this.fs = filesystem;
     this.lockAcquired = false;
     this.identity = null;
+    this.token = null;
+    this.monitorOwner = monitorOwner;
   }
 
   acquire(timeout = LOCK_TIMEOUT_MS) {
@@ -22,7 +24,8 @@ class LockManager {
       }
     };
     while (Date.now() - started < timeout) {
-      const temp = `${this.lockFilePath}.${process.pid}.${crypto.randomUUID()}`;
+      const token = crypto.randomUUID();
+      const temp = `${this.lockFilePath}.${process.pid}.${token}`;
       try {
         try {
           const stat = this.fs.statSync(this.lockFilePath);
@@ -44,6 +47,8 @@ class LockManager {
             pid: process.pid,
             timestamp: Date.now(),
             hostname: os.hostname(),
+            processStart: this.processInfo(process.pid)?.start,
+            token,
           }),
           { flag: 'wx' }
         );
@@ -56,6 +61,7 @@ class LockManager {
         const identity = this.fs.statSync(temp);
         this.fs.linkSync(temp, this.lockFilePath);
         this.identity = identity;
+        this.token = token;
         this.lockAcquired = true;
         debug(`acquired after ${Date.now() - started}ms`);
         return true;
@@ -84,7 +90,8 @@ class LockManager {
       const current = this.fs.statSync(this.lockFilePath);
       if (
         current.dev === this.identity.dev &&
-        current.ino === this.identity.ino
+        current.ino === this.identity.ino &&
+        this.readLockFile()?.token === this.token
       ) {
         this.fs.unlinkSync(this.lockFilePath);
       }
@@ -92,6 +99,7 @@ class LockManager {
       /* The lock may already be gone. */
     }
     this.lockAcquired = false;
+    this.token = null;
   }
 
   readLockFile() {
@@ -117,6 +125,32 @@ class LockManager {
     if (data.hostname === os.hostname()) {
       try {
         process.kill(data.pid, 0);
+        const info = this.processInfo(data.pid);
+        if (
+          info &&
+          (['Z', 'X', 'x'].includes(info.state) ||
+            (data.processStart && data.processStart !== info.start))
+        ) {
+          return true;
+        }
+        if (
+          this.monitorOwner &&
+          !data.processStart &&
+          process.platform === 'linux'
+        ) {
+          try {
+            const command = this.fs.readFileSync(
+              `/proc/${data.pid}/cmdline`,
+              'utf8'
+            );
+            return (
+              !command.includes('cpu-penalty-monitor') &&
+              !command.includes('__start-cpu-monitor')
+            );
+          } catch {
+            /* Proc may be restricted; do not evict an unverified live owner. */
+          }
+        }
         return false;
       } catch (error) {
         return error.code === 'ESRCH';
@@ -125,6 +159,23 @@ class LockManager {
     return Date.now() - data.timestamp > LOCK_STALE_MS;
   }
 
+  processInfo(pid) {
+    if (process.platform !== 'linux') {
+      return null;
+    }
+    try {
+      const stat = this.fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+      // comm is parenthesized and can contain spaces and closing parentheses.
+      const fields = stat
+        .slice(stat.lastIndexOf(')') + 2)
+        .trim()
+        .split(/\s+/);
+      return { state: fields[0], start: fields[19] };
+    } catch {
+      return null;
+    }
+  }
+
   sleep(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
   }

package/test/regression-207.js

@@ -0,0 +1,249 @@
+const { it, expect } = require('bun:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { initialState, transitionLog } = require('../src/lib/cpu-penalty');
+const cpu = require('../src/lib/cpu-penalty-monitor');
+
+it('restarted monitors retain an observed base absent from launch flags', () => {
+  const saved = { ...initialState(4, 0), phase: 'penalized', limitCpus: 2 };
+  expect(initialState(null, 100, saved).baseCpus).toBe(4);
+});
+
+it('saved observing limits preserve the base after a daemon-clamped lift', () => {
+  const saved = { ...initialState(4, 0), limitCpus: 1 };
+  const { observeBase } = require('../src/lib/cpu-penalty');
+  expect(observeBase(initialState(null, 100, saved), 1, 100).baseCpus).toBe(4);
+});
+
+for (const mode of [
+  'nano',
+  'quota',
+  'restart',
+  'zombie',
+  'reused',
+  'supervise',
+  'publish-fault',
+  'graceful',
+  'override',
+]) {
+  it(`CPU monitor recovers external base and idle release: ${mode}`, () => {
+    if (
+      process.platform === 'win32' ||
+      (['zombie', 'reused'].includes(mode) && process.platform !== 'linux')
+    ) {
+      return;
+    }
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cpu-monitor-207-'));
+    try {
+      const logPath = path.join(dir, 'task.log');
+      fs.writeFileSync(logPath, '');
+      const record = {
+        logPath,
+        options: {
+          sessionName: 'cpu-task',
+          isolated: 'docker',
+          cpuPenaltyConfig: {
+            cpus: 2,
+            trigger: 95,
+            release: 65,
+            triggerWindowMs: 400,
+            releaseWindowMs: 400,
+          },
+          baseResourceLimits: [],
+        },
+      };
+      const command = [
+        process.execPath,
+        require.resolve('../src/lib/cpu-penalty-monitor'),
+        '',
+        'cpu-task',
+        '1',
+        JSON.stringify(record),
+      ];
+      if (mode === 'supervise') {
+        const script = `${cpu.startSnippet(null, 'cpu-task', 1, { ...record.options, logPath })}; read done; ${cpu.stopSnippet()}`;
+        command.splice(0, command.length, 'sh', '-c', script);
+      }
+      const result = spawnSync(
+        'python3',
+        [
+          path.resolve(__dirname, '../../experiments/issue-207-monitor.py'),
+          mode,
+          logPath,
+          ...command,
+        ],
+        { encoding: 'utf8' }
+      );
+      expect(result.status, result.stderr).toBe(0);
+      const state = cpu.readState(record);
+      const expected = mode === 'override' ? 3 : 4;
+      expect(state.baseCpus).toBe(expected);
+      expect(state.phase).toBe('observing');
+      expect(state.limitCpus).toBe(expected);
+      if (mode !== 'override') {
+        expect(fs.readFileSync(logPath, 'utf8')).toContain(
+          'CPU penalty lifted: 4'
+        );
+      }
+      const { ExecutionRecord } = require('../src/lib/execution-store');
+      const {
+        enrichDetachedStatus,
+        formatRecord,
+      } = require('../src/lib/status-formatter');
+      const statusRecord = new ExecutionRecord({
+        ...record,
+        options: { ...record.options, isolated: undefined },
+      });
+      const status = JSON.parse(
+        formatRecord(enrichDetachedStatus(statusRecord), 'json')
+      );
+      expect(status.cpuPenalty.baseCpus).toBe(expected);
+      expect(status.cpuPenalty.limitCpus).toBe(expected);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }, 15000);
+}
+
+for (const failure of ['inspect', 'stats', 'update', 'publish']) {
+  it(`an exception in ${failure} resets coverage and monitoring continues`, async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cpu-tick-207-'));
+    const logPath = path.join(dir, 'task.log');
+    const record = {
+      logPath,
+      options: {
+        sessionName: 'cpu-task',
+        cpuPenaltyConfig: {
+          cpus: 2,
+          trigger: 95,
+          release: 65,
+          triggerWindowMs: 100,
+          releaseWindowMs: 100,
+        },
+      },
+    };
+    let ticks = 0;
+    let injected = false,
+      limit = 4,
+      lifted = false;
+    const filesystem = Object.create(fs);
+    filesystem.renameSync = (from, to) => {
+      if (
+        failure === 'publish' &&
+        !injected &&
+        JSON.parse(fs.readFileSync(from)).phase === 'penalized'
+      ) {
+        injected = true;
+        throw new Error('injected ENOSPC');
+      }
+      fs.renameSync(from, to);
+    };
+    try {
+      await cpu.monitor('', 'cpu-task', 1, JSON.stringify(record), {
+        fs: filesystem,
+        run: (_command, args) => {
+          if (args[0] === failure && !injected) {
+            injected = true;
+            throw new Error(`injected ${failure}`);
+          }
+          const result = (stdout) => ({ success: true, stdout });
+          if (args[0] === 'inspect') {
+            if (!args[2].includes('HostConfig') && ++ticks > 60) {
+              lifted = false;
+              return result('false');
+            }
+            return result(
+              args[2].includes('HostConfig')
+                ? JSON.stringify({ NanoCpus: limit * 1e9 })
+                : String(!lifted)
+            );
+          }
+          if (args[0] === 'info') {
+            return result('{"NCPU":6}');
+          }
+          if (args[0] === 'stats') {
+            return result(
+              JSON.stringify({
+                Name: 'cpu-task',
+                CPUPerc: limit === 2 ? '20%' : '400%',
+              })
+            );
+          }
+          if (args[0] === 'update') {
+            limit = Number(args[2]);
+            lifted = limit === 4;
+            return result('');
+          }
+          throw new Error('unexpected command');
+        },
+      });
+      expect(injected).toBe(true);
+      expect(lifted).toBe(true);
+      expect(cpu.readState(record).baseCpus).toBe(4);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }, 5000);
+}
+
+it('stopped resume uses the observed base rather than the temporary quota', () => {
+  const { restoreBaseCpu } = require('../src/lib/resume-resources');
+  expect(
+    restoreBaseCpu(
+      ['--memory=512m', '--cpus=2'],
+      { cpuPenaltyConfig: {}, baseResourceLimits: [] },
+      { baseCpus: 4 }
+    )
+  ).toEqual(['--memory=512m', '--cpus=4']);
+});
+
+it('stopped resume preserves a later supervisor override instead of the stale cap', () => {
+  const { restoreBaseCpu } = require('../src/lib/resume-resources');
+  const options = { cpuPenaltyConfig: {}, baseResourceLimits: [] };
+  const saved = { phase: 'penalized', baseCpus: 4, limitCpus: 2 };
+  expect(restoreBaseCpu(['--cpus=2'], options, saved, true)).toEqual([
+    '--cpus=4',
+  ]);
+  expect(restoreBaseCpu(['--cpus=3'], options, saved, true)).toEqual([
+    '--cpus=3',
+  ]);
+});
+
+it('transition logs explain the window and phase denominator', () => {
+  const config = { cpus: 2, triggerWindowMs: 900000, releaseWindowMs: 400 };
+  expect(
+    transitionLog({ kind: 'apply', cpus: 2, capacity: 4, average: 100 }, config)
+  ).toContain('of 4 CPUs for 15m');
+  expect(
+    transitionLog({ kind: 'lift', cpus: 4, capacity: 4, average: 10 }, config)
+  ).toContain('of 2 CPUs for 400ms');
+});
+
+it('process birth identity reclaims reused PIDs without evicting a live lock', () => {
+  if (process.platform !== 'linux') {
+    return;
+  }
+  const { LockManager } = require('../src/lib/store-lock');
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cpu-lock-207-'));
+  const file = path.join(dir, 'lock');
+  const first = new LockManager(file);
+  const replacement = new LockManager(file);
+  try {
+    expect(first.acquire(100)).toBe(true);
+    const data = JSON.parse(fs.readFileSync(file));
+    expect(data.processStart).toBeTruthy();
+    expect(replacement.acquire(100)).toBe(false);
+    fs.writeFileSync(
+      file,
+      JSON.stringify({ ...data, processStart: 'different-birth' })
+    );
+    expect(replacement.acquire(100)).toBe(true);
+    first.release();
+    expect(fs.existsSync(file)).toBe(true);
+  } finally {
+    replacement.release();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/shared-golden.js

@@ -51,4 +51,27 @@ describe('shared JavaScript and Rust golden contracts', () => {
       );
     }
   });
+  for (const fixture of fixtures['cpu-penalty-state']) {
+    it(`CPU state: ${fixture.name}`, () => {
+      const {
+        initialState,
+        observeBase,
+        evaluate,
+      } = require('../src/lib/cpu-penalty');
+      let state = initialState(fixture.baseCpus, 0, fixture.saved);
+      for (const step of fixture.steps) {
+        state = observeBase(state, step.baseCpus, step.now);
+        const decision = evaluate(
+          state,
+          { now: step.now, cores: step.cores, daemonCpus: 6, maxGapMs: 50 },
+          fixture.config
+        );
+        assert.equal(decision.action?.kind || null, step.action);
+        state = decision.state;
+      }
+      for (const [key, value] of Object.entries(fixture.expected)) {
+        assert.deepEqual(state[key], value, key);
+      }
+    });
+  }
 });