start-command 0.38.0 → 0.39.1

package/src/lib/status-formatter.js

@@ -14,7 +14,7 @@ const {
   formatTextOptionValue,
 } = require('./status-links-notation');
 const { collectProcessIds } = require('./execution-control');
-const { getDockerCommand, getDockerSpawnOptions } = require('./docker-cleanup');
+const { getDockerCommand } = require('./docker-cleanup');
 const {
   describeExitCode,
   CGROUP_OOM_EXIT_REASON,
@@ -25,136 +25,31 @@ const {
   FATAL_MARKER_TAIL_BYTES,
   readLogTail,
 } = require('./isolation-log-utils');
-const { normalizeDockerTimestamp } = require('./docker-post-mortem');
 const { END_TIME_SOURCE } = require('./detached-finalize');
 const { formatCgroupMemory } = require('./cgroup-memory');
+const { addLostWatcherEvidence } = require('./exit-evidence');
 const {
   attachContainerRemoval,
-  dockerInspect,
   persistContainerRemoval,
 } = require('./container-removal');
-
-/**
- * Inspect the live state of a detached docker container by name.
- *
- * Distinguishes three outcomes that matter for status reporting:
- * - the container exists and is running,
- * - the container exists but has stopped (with a real exit code), and
- * - the container cannot be inspected at all.
- *
- * The last case is crucial on slow Docker-in-Docker hosts (issue #136): right
- * after `docker run -d` returns, `docker inspect <name>` can transiently fail
- * because the container is not visible yet. A failed inspect must NOT be read
- * as "stopped"; it means "unknown", so callers can keep the session running
- * instead of fabricating a terminal `-1` result.
- *
- * @param {string} sessionName - Container name
- * @param {Object|null} [probe] - Receives `sessionNotFound` (issue #225)
- * @returns {{running: boolean, exitCode: number|null, oomKilled: boolean|null}|null} State,
- *   or null when the container cannot be inspected (not found yet, removed, or docker error)
- */
-function inspectDockerState(sessionName, probe = null) {
-  const { stdout, notFound } = dockerInspect(
-    getDockerCommand(),
-    dockerProbeSpawnOptions(),
-    '{{.State.Running}} {{.State.ExitCode}} {{.State.OOMKilled}} ' +
-      '{{.State.StartedAt}} {{.State.FinishedAt}}',
-    sessionName
-  );
-  if (probe) {
-    // "No such container" is a fact, unlike a docker that cannot be reached
-    // (issue #225); it still reads as unknown liveness here (issue #136).
-    probe.sessionNotFound = notFound;
-  }
-  if (stdout === null) {
-    return null;
-  }
-  // Parsed positionally and defensively: an older docker (or a stubbed one)
-  // may answer with fewer fields than the template asks for.
-  const [runningRaw, exitRaw, oomKilledRaw, startedRaw, finishedRaw] = stdout
-    .trim()
-    .split(/\s+/);
-  const exitCode = Number.parseInt(exitRaw, 10);
+const { withDockerInspectBatch } = require('./docker-inspect-batch');
+const {
+  backendExitCode,
+  dockerProbeSpawnOptions,
+  inspectDockerState,
+  isDetachedDockerRecord,
+  readDockerState,
+  resolveOomObservation,
+} = require('./status-probe');
+
+/** How the status probes run docker. */
+function dockerProbe() {
   return {
-    running: runningRaw === 'true',
-    exitCode: Number.isFinite(exitCode) ? exitCode : null,
-    oomKilled:
-      oomKilledRaw === 'true' ? true : oomKilledRaw === 'false' ? false : null,
-    startedAt: normalizeDockerTimestamp(startedRaw),
-    finishedAt: normalizeDockerTimestamp(finishedRaw),
+    dockerCommand: getDockerCommand(),
+    spawnOptions: dockerProbeSpawnOptions(),
   };
 }
 
-function isDetachedDockerRecord(record) {
-  const opts = record.options || {};
-  return (
-    opts.isolated === 'docker' &&
-    opts.isolationMode === 'detached' &&
-    Boolean(opts.sessionName)
-  );
-}
-
-function dockerProbeSpawnOptions() {
-  return getDockerSpawnOptions({
-    encoding: 'utf8',
-    env: process.env,
-    stdio: ['pipe', 'pipe', 'pipe'],
-  });
-}
-
-function readDockerState(record, probe = null) {
-  const opts = record.options || {};
-  if (opts.isolated !== 'docker' || !opts.sessionName) {
-    return null;
-  }
-  const state = inspectDockerState(opts.sessionName, probe);
-  if (
-    record.attempt &&
-    state?.startedAt &&
-    Date.parse(state.startedAt) < Date.parse(record.attempt.startedAt)
-  ) {
-    return null;
-  }
-  return state;
-}
-
-/**
- * Best-effort terminal exit code reported by the isolation backend itself
- * (currently docker via `docker inspect .State.ExitCode`). Returns null when
- * the backend cannot provide a real code, so callers never surface the `-1`
- * sentinel for a session whose real exit code is simply not available yet.
- * A running container has no terminal exit code (docker reports `0` for it),
- * so only a stopped container contributes one.
- * @param {{running: boolean, exitCode: number|null}|null} dockerState - Inspected state
- * @returns {number|null}
- */
-function backendExitCode(dockerState) {
-  return dockerState && !dockerState.running ? dockerState.exitCode : null;
-}
-
-/**
- * Reconcile the OOM observation from the stored record and from `docker inspect`.
- *
- * `State.OOMKilled` is a container-cgroup flag: the kernel sets it when ANY
- * process in the cgroup is OOM-killed and it is never cleared for the life of
- * the container (moby/moby#47618). It is therefore an *observation*, never a
- * verdict about the session (issue #151) — a container that lost one child
- * process keeps running and can still exit `0`. Once observed, the flag stays
- * `true` for the record.
- * @param {Object} record - Execution record
- * @param {{oomKilled: boolean|null}|null} dockerState - Inspected state
- * @returns {boolean|undefined} Observation, or undefined when nothing is known
- */
-function resolveOomObservation(record, dockerState) {
-  if (record.oomKilled === true || dockerState?.oomKilled === true) {
-    return true;
-  }
-  if (record.oomKilled === false || dockerState?.oomKilled === false) {
-    return false;
-  }
-  return undefined;
-}
-
 /**
  * Check if a detached isolation session is still running
  * @param {Object} record - Execution record
@@ -433,6 +328,7 @@ function resolveDetachedStatus(record, logTail, probe = null) {
         (oomKilled === true ? 137 : -1);
     }
     applyEndTime(enriched, dockerState, footer.finishedAt);
+    addLostWatcherEvidence(enriched, record, dockerState, logTail);
   }
 
   return enriched;
@@ -563,10 +459,7 @@ function enrichDetachedStatus(record) {
   const logTail = record
     ? readAttemptLogTail(record, FATAL_MARKER_TAIL_BYTES)
     : null;
-  const probe = {
-    dockerCommand: getDockerCommand(),
-    spawnOptions: dockerProbeSpawnOptions(),
-  };
+  const probe = dockerProbe();
   const resolved = attachContainerRemoval(
     resolveDetachedStatus(record, logTail, probe),
     probe
@@ -920,10 +813,17 @@ function queryStatus(store, identifier, outputFormat) {
     };
   }
   try {
-    // Enrich detached execution status with live session check
-    const enrichedRecord = enrichDetachedStatus(record);
-    persistContainerRemoval(store, record, enrichedRecord);
-    const withProcessIds = attachProcessIds(enrichedRecord);
+    // Enrich detached execution status with live session check; its docker
+    // probes are answered by one inspect (issue #243).
+    const withProcessIds = withDockerInspectBatch(
+      [record],
+      dockerProbe(),
+      () => {
+        const enrichedRecord = enrichDetachedStatus(record);
+        persistContainerRemoval(store, record, enrichedRecord);
+        return attachProcessIds(enrichedRecord);
+      }
+    );
     // Attach currentTime so callers can see how long an executing command has been running
     const withCurrentTime = require('./execution-chain').attachIdentity(
       attachCurrentTime(withProcessIds),
@@ -952,8 +852,12 @@ function listExecutions(store, outputFormat, options = {}) {
   }
 
   try {
+    const all = store.getAll();
+    // One docker inspect for every listed container (issue #243).
     const enriched = sortRecordsByStartTimeDesc(
-      store.getAll().map(prepareRecordForList)
+      withDockerInspectBatch(all, dockerProbe(), () =>
+        all.map(prepareRecordForList)
+      )
     );
     // --running reports the reconciled status, not the stored one: a record
     // whose session already died is listed as executed even if the store still

package/src/lib/status-probe.js

@@ -0,0 +1,149 @@
+/**
+ * Live docker state of a detached execution, for `--status` and `--list`.
+ *
+ * Split out of `status-formatter` (as `status_probe.rs` is in Rust) so the
+ * probing stays separate from the rendering and both files stay under the
+ * repository line budget (issue #243).
+ */
+
+const { getDockerCommand, getDockerSpawnOptions } = require('./docker-cleanup');
+const { normalizeDockerTimestamp } = require('./docker-post-mortem');
+const {
+  CONTAINER_STATE_REMOVED,
+  dockerInspect,
+} = require('./container-removal');
+
+/**
+ * Inspect the live state of a detached docker container by name.
+ *
+ * Distinguishes three outcomes that matter for status reporting:
+ * - the container exists and is running,
+ * - the container exists but has stopped (with a real exit code), and
+ * - the container cannot be inspected at all.
+ *
+ * The last case is crucial on slow Docker-in-Docker hosts (issue #136): right
+ * after `docker run -d` returns, `docker inspect <name>` can transiently fail
+ * because the container is not visible yet. A failed inspect must NOT be read
+ * as "stopped"; it means "unknown", so callers can keep the session running
+ * instead of fabricating a terminal `-1` result.
+ *
+ * @param {string} sessionName - Container name
+ * @param {Object|null} [probe] - Receives `sessionNotFound` (issue #225)
+ * @returns {{running: boolean, exitCode: number|null, oomKilled: boolean|null}|null} State,
+ *   or null when the container cannot be inspected (not found yet, removed, or docker error)
+ */
+function inspectDockerState(sessionName, probe = null) {
+  const { stdout, notFound } = dockerInspect(
+    getDockerCommand(),
+    dockerProbeSpawnOptions(),
+    '{{.State.Running}} {{.State.ExitCode}} {{.State.OOMKilled}} ' +
+      '{{.State.StartedAt}} {{.State.FinishedAt}}',
+    sessionName
+  );
+  if (probe) {
+    // "No such container" is a fact, unlike a docker that cannot be reached
+    // (issue #225); it still reads as unknown liveness here (issue #136).
+    probe.sessionNotFound = notFound;
+  }
+  if (stdout === null) {
+    return null;
+  }
+  // Parsed positionally and defensively: an older docker (or a stubbed one)
+  // may answer with fewer fields than the template asks for.
+  const [runningRaw, exitRaw, oomKilledRaw, startedRaw, finishedRaw] = stdout
+    .trim()
+    .split(/\s+/);
+  const exitCode = Number.parseInt(exitRaw, 10);
+  return {
+    running: runningRaw === 'true',
+    exitCode: Number.isFinite(exitCode) ? exitCode : null,
+    oomKilled:
+      oomKilledRaw === 'true' ? true : oomKilledRaw === 'false' ? false : null,
+    startedAt: normalizeDockerTimestamp(startedRaw),
+    finishedAt: normalizeDockerTimestamp(finishedRaw),
+  };
+}
+
+function isDetachedDockerRecord(record) {
+  const opts = record.options || {};
+  return (
+    opts.isolated === 'docker' &&
+    opts.isolationMode === 'detached' &&
+    Boolean(opts.sessionName)
+  );
+}
+
+function dockerProbeSpawnOptions() {
+  return getDockerSpawnOptions({
+    encoding: 'utf8',
+    env: process.env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+}
+
+function readDockerState(record, probe = null) {
+  const opts = record.options || {};
+  if (opts.isolated !== 'docker' || !opts.sessionName) {
+    return null;
+  }
+  if (record.containerState === CONTAINER_STATE_REMOVED) {
+    // A removed container stays removed: a relaunch clears the marker, so
+    // there is nothing left to ask Docker (issue #243).
+    return null;
+  }
+  const state = inspectDockerState(opts.sessionName, probe);
+  if (
+    record.attempt &&
+    state?.startedAt &&
+    Date.parse(state.startedAt) < Date.parse(record.attempt.startedAt)
+  ) {
+    return null;
+  }
+  return state;
+}
+
+/**
+ * Best-effort terminal exit code reported by the isolation backend itself
+ * (currently docker via `docker inspect .State.ExitCode`). Returns null when
+ * the backend cannot provide a real code, so callers never surface the `-1`
+ * sentinel for a session whose real exit code is simply not available yet.
+ * A running container has no terminal exit code (docker reports `0` for it),
+ * so only a stopped container contributes one.
+ * @param {{running: boolean, exitCode: number|null}|null} dockerState - Inspected state
+ * @returns {number|null}
+ */
+function backendExitCode(dockerState) {
+  return dockerState && !dockerState.running ? dockerState.exitCode : null;
+}
+
+/**
+ * Reconcile the OOM observation from the stored record and from `docker inspect`.
+ *
+ * `State.OOMKilled` is a container-cgroup flag: the kernel sets it when ANY
+ * process in the cgroup is OOM-killed and it is never cleared for the life of
+ * the container (moby/moby#47618). It is therefore an *observation*, never a
+ * verdict about the session (issue #151) — a container that lost one child
+ * process keeps running and can still exit `0`. Once observed, the flag stays
+ * `true` for the record.
+ * @param {Object} record - Execution record
+ * @param {{oomKilled: boolean|null}|null} dockerState - Inspected state
+ * @returns {boolean|undefined} Observation, or undefined when nothing is known
+ */
+function resolveOomObservation(record, dockerState) {
+  if (record.oomKilled === true || dockerState?.oomKilled === true) {
+    return true;
+  }
+  if (record.oomKilled === false || dockerState?.oomKilled === false) {
+    return false;
+  }
+  return undefined;
+}
+
+module.exports = {
+  backendExitCode,
+  dockerProbeSpawnOptions,
+  inspectDockerState,
+  isDetachedDockerRecord,
+  readDockerState,
+  resolveOomObservation,
+};

package/src/lib/store-decode-cache.js

@@ -0,0 +1,141 @@
+/**
+ * Decoded execution store, shared within one process and between processes
+ * (issue #243).
+ *
+ * Decoding `executions.lino` costs about 1-4 ms per record, and one
+ * `--status` used to decode it up to three times (`get`, then `getAll` twice
+ * for the execution chain). The file is still read on every call, so a write
+ * by any process is seen at once, but it is decoded again only when its
+ * content differs from the last decoded copy. The content itself is the key:
+ * unlike an mtime, it cannot miss two same-size writes within one clock tick.
+ *
+ * A new process (every `$ --status` poll) still had to decode once. The
+ * decoded records are therefore also kept as JSON next to the store, tagged
+ * with the SHA-256 of the content they were decoded from; `JSON.parse` of
+ * that copy is about 250 times faster than the lino decode. A copy whose
+ * digest does not match the current content is ignored and replaced.
+ */
+
+const fs = require('fs');
+const crypto = require('crypto');
+const { isDeepStrictEqual } = require('util');
+const { atomicWrite } = require('./atomic-write');
+
+/** Format tag of the JSON copy; a different tag is ignored. */
+const DECODED_COPY_FORMAT = 'start-command-decoded-store-js-1';
+
+/** @type {Map<string, {content: string, data: *, decodes: number}>} */
+const decodedStores = new Map();
+
+function digestOf(content) {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+/**
+ * Records of the JSON copy at `copyPath`, when it was decoded from content
+ * with this digest; otherwise undefined.
+ */
+function readDecodedCopy(copyPath, digest) {
+  try {
+    const copy = JSON.parse(fs.readFileSync(copyPath, 'utf8'));
+    if (copy && copy.format === DECODED_COPY_FORMAT && copy.sha256 === digest) {
+      return copy.records;
+    }
+  } catch {
+    /* Missing or unreadable: decode instead. */
+  }
+  return undefined;
+}
+
+/**
+ * Keep `data` as JSON for the next process, unless JSON cannot represent it
+ * exactly. Best effort: a read-only folder only costs the next decode.
+ */
+function writeDecodedCopy(copyPath, digest, data) {
+  try {
+    const json = JSON.stringify({
+      format: DECODED_COPY_FORMAT,
+      sha256: digest,
+      records: data,
+    });
+    if (!isDeepStrictEqual(JSON.parse(json).records, data)) {
+      return;
+    }
+    atomicWrite(copyPath, json);
+  } catch {
+    /* Not kept; the next process decodes again. */
+  }
+}
+
+/**
+ * Decode `content` of the store at `filePath`, or reuse an earlier decode of
+ * the same content. Every call returns its own deep copy, so callers may
+ * mutate the records they get.
+ * @param {string} filePath - Store file the content was read from
+ * @param {string} content - Current file content
+ * @param {function(string): *} decode - Decoder for a changed content
+ * @param {{copyPath?: string}} [options] - JSON copy shared between processes
+ * @returns {{data: *, reused: boolean, source: 'memory'|'copy'|'decode'}}
+ */
+function decodeStoreContent(filePath, content, decode, options = {}) {
+  const cached = decodedStores.get(filePath);
+  if (cached && cached.content === content) {
+    return {
+      data: structuredClone(cached.data),
+      reused: true,
+      source: 'memory',
+    };
+  }
+  const decodes = cached ? cached.decodes : 0;
+  const { copyPath } = options;
+  const digest = copyPath ? digestOf(content) : null;
+  const copied = copyPath ? readDecodedCopy(copyPath, digest) : undefined;
+  if (copied !== undefined) {
+    decodedStores.set(filePath, {
+      content,
+      data: structuredClone(copied),
+      decodes,
+    });
+    return { data: copied, reused: true, source: 'copy' };
+  }
+  const data = decode(content);
+  decodedStores.set(filePath, {
+    content,
+    data: structuredClone(data),
+    decodes: decodes + 1,
+  });
+  if (copyPath) {
+    writeDecodedCopy(copyPath, digest, data);
+  }
+  return { data, reused: false, source: 'decode' };
+}
+
+/**
+ * How many times this process decoded the store at `filePath` since it was
+ * last forgotten.
+ * @param {string} filePath - Store file
+ * @returns {number}
+ */
+function decodeCount(filePath) {
+  const cached = decodedStores.get(filePath);
+  return cached ? cached.decodes : 0;
+}
+
+/**
+ * Drop the decoded copy of a store held by this process.
+ * @param {string} [filePath] - Store file; all stores when omitted
+ */
+function forgetDecodedStore(filePath) {
+  if (filePath === undefined) {
+    decodedStores.clear();
+  } else {
+    decodedStores.delete(filePath);
+  }
+}
+
+module.exports = {
+  DECODED_COPY_FORMAT,
+  decodeCount,
+  decodeStoreContent,
+  forgetDecodedStore,
+};

package/src/lib/usage.js

@@ -18,12 +18,14 @@ Options:
   --env, -e <KEY=VALUE> Environment variable for docker container (repeatable, docker only)
   --label <KEY=VALUE>   Container attribution (repeatable, docker only; start-command.* reserved)
   --privileged          Run docker container in privileged mode (docker only)
+  --init, --no-init     Run tini as PID 1 to reap orphaned processes (docker only; default START_COMMAND_DOCKER_INIT=1)
   --network <name>      Connect to a named network (repeatable, docker only)
   --network-alias <alias> Add alias to the first network (repeatable, docker only)
   --on-kill-resume <N>  Resume a killed (exit 137 / OOM) detached docker session up to N times
   --recovery-command <cmd>  Command to run in the same container on such a resume
   --on-kill-resume-delay <min[-max]>  Wait a random number of seconds before each such resume (default 0)
   --memory <size|N%|MIN%-MAX%>  Docker RAM cap; percentages use daemon capacity
+  --memory-reservation <spec>  Soft memory limit (Docker size or N%, below --memory)
   --memory-swap <spec>  Combined memory+swap cap (defaults to memory, no extra swap)
   --cpus <n|N%|MIN%-MAX%>  Docker CPU cap; ranges draw once per creation
   --on-kill-resume-memory <spec>  New memory cap before a qualifying OOM recovery
@@ -79,6 +81,7 @@ Examples:
   $ --isolated docker --image ghcr.io/link-foundation/box-js:latest -- bun --version
   $ -i docker -v ~/.config/gh:/root/.config/gh -e TOKEN=abc -- gh repo list
   $ -i docker --image konard/hive-mind-dind:latest --privileged -- solve ...
+  $ -i docker --init -d -- solve ...       # tini reaps zombies of long-running tasks
   $ --isolated ssh --endpoint user@remote.server -- ls -la
   $ --isolated-user -- npm test            # Create isolated user
   $ -u myuser -- npm start                 # Custom username

package/test/cargo-lock-version.mjs

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'bun:test';
+import { mkdtempSync, readFileSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import {
+  setCargoLockPackageVersion,
+  syncCargoLockVersion,
+} from '../../scripts/cargo-lock-version.mjs';
+
+const repoRoot = path.resolve(import.meta.dir, '../..');
+const lock = (version, eol = '\n') =>
+  [
+    '# This file is automatically @generated by Cargo.',
+    'version = 4',
+    '',
+    '[[package]]',
+    'name = "start-command"',
+    `version = "${version}"`,
+    'dependencies = [',
+    ' "serde",',
+    ']',
+    '',
+    '[[package]]',
+    'name = "start-command-helper"',
+    'version = "9.9.9"',
+    '',
+  ].join(eol);
+
+describe('setCargoLockPackageVersion', () => {
+  it('rewrites only the named package entry', () => {
+    const result = setCargoLockPackageVersion(
+      lock('0.23.0'),
+      'start-command',
+      '0.27.0'
+    );
+    expect(result).toEqual({
+      text: lock('0.27.0'),
+      found: true,
+      changed: true,
+    });
+    expect(result.text).toContain('version = "9.9.9"');
+  });
+
+  it('reports an already synced entry as unchanged', () => {
+    expect(
+      setCargoLockPackageVersion(lock('0.27.0'), 'start-command', '0.27.0')
+    ).toEqual({ text: lock('0.27.0'), found: true, changed: false });
+  });
+
+  it('keeps CRLF line endings', () => {
+    expect(
+      setCargoLockPackageVersion(
+        lock('0.1.0', '\r\n'),
+        'start-command',
+        '0.2.0'
+      ).text
+    ).toBe(lock('0.2.0', '\r\n'));
+  });
+
+  it('does not match a package whose name only starts with the crate name', () => {
+    expect(
+      setCargoLockPackageVersion(lock('0.1.0'), 'start', '1.0.0').found
+    ).toBe(false);
+  });
+});
+
+describe('syncCargoLockVersion', () => {
+  it('writes the file only when the version changes', () => {
+    const file = path.join(mkdtempSync(path.join(tmpdir(), 'lock-')), 'l');
+    writeFileSync(file, lock('0.1.0'));
+    expect(syncCargoLockVersion(file, 'start-command', '0.2.0')).toBe(true);
+    expect(readFileSync(file, 'utf8')).toBe(lock('0.2.0'));
+    expect(syncCargoLockVersion(file, 'start-command', '0.2.0')).toBe(false);
+  });
+
+  it('skips a missing lock file and rejects a lock without the crate', () => {
+    const dir = mkdtempSync(path.join(tmpdir(), 'lock-'));
+    expect(
+      syncCargoLockVersion(path.join(dir, 'none'), 'start-command', '1.0.0')
+    ).toBe(false);
+    const file = path.join(dir, 'Cargo.lock');
+    writeFileSync(file, lock('0.1.0'));
+    expect(() => syncCargoLockVersion(file, 'other', '1.0.0')).toThrow(
+      /no \[\[package\]\] entry for other/
+    );
+  });
+});
+
+describe('repository Cargo.lock (issue #234)', () => {
+  it('records the Cargo.toml version of the crate', () => {
+    const manifest = readFileSync(
+      path.join(repoRoot, 'rust/Cargo.toml'),
+      'utf8'
+    );
+    const name = manifest.match(/^name\s*=\s*"([^"]+)"/m)[1];
+    const version = manifest.match(/^version\s*=\s*"([^"]+)"/m)[1];
+    const result = setCargoLockPackageVersion(
+      readFileSync(path.join(repoRoot, 'rust/Cargo.lock'), 'utf8'),
+      name,
+      version
+    );
+    expect(result.found).toBe(true);
+    expect(result.changed).toBe(false);
+  });
+
+  it('is synced and staged by both Rust version bump scripts', () => {
+    for (const script of ['version-and-commit.mjs', 'bump-version.mjs']) {
+      const source = readFileSync(
+        path.join(repoRoot, 'scripts', script),
+        'utf8'
+      );
+      expect(source).toContain("syncCargoLockVersion('Cargo.lock'");
+    }
+    expect(
+      readFileSync(
+        path.join(repoRoot, 'scripts/version-and-commit.mjs'),
+        'utf8'
+      )
+    ).toContain("['Cargo.toml', 'Cargo.lock', 'CHANGELOG.md', 'changelog.d']");
+  });
+});