start-command 0.37.9 → 0.39.0

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
@@ -729,6 +622,7 @@ function formatRecordAsText(record) {
     `UUID:              ${obj.uuid}`,
     `Status:            ${obj.status}`,
     `Command:           ${obj.command}`,
+    ...require('./execution-chain').identityTextLines(obj),
     `Exit Code:         ${obj.exitCode !== null ? describeExitCode(obj.exitCode).text : 'N/A'}`,
     ...(obj.oomKilled !== undefined
       ? [`OOM Killed:        ${obj.oomKilled}`]
@@ -919,12 +813,22 @@ 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 = attachCurrentTime(withProcessIds);
+    const withCurrentTime = require('./execution-chain').attachIdentity(
+      attachCurrentTime(withProcessIds),
+      store
+    );
     return {
       success: true,
       output: formatRecord(withCurrentTime, outputFormat || 'links-notation'),
@@ -948,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

@@ -1,6 +1,6 @@
 /** Print usage information */
 function printUsage() {
-  console.log(`Usage: $ [options] [--] <command> | $ --status <uuid> [--output-format <fmt>] | $ --list [--running] [--output-format <fmt>] | $ --upload-log <id> | $ --stop <id> | $ --terminate <id> | $ --attach <id> [--read-only] | $ --resume <id> [-- <command>] | $ --resume-all
+  console.log(`Usage: $ [options] [--] <command> | $ --status <uuid> [--output-format <fmt>] | $ --list [--running] [--output-format <fmt>] | $ --upload-log <id> | $ --stop <id> | $ --terminate <id> | $ --attach <id> [--read-only] | $ --resume <id> [-- <command>] | $ --resume-all | $ --alias <id> <name> | $ --rename <id> <name>
 
 Options:
   --help, -h           Show this usage and exit successfully
@@ -10,18 +10,22 @@ Options:
   --session, -s <name>  Session name for isolation
   --session-id <uuid>   Session UUID for tracking (auto-generated if not provided)
   --session-name <uuid> Alias for --session-id
+  --append-attempt      Run as the next attempt of the existing --session-id execution
+  --continues <id>      Record that this execution continues an earlier one
   --image <image>       Docker image (optional, defaults to OS-matched image)
   --volume, -v <spec>   Docker bind mount/volume host:container[:mode] (repeatable, docker only)
   --mount <spec>        Docker --mount spec (repeatable, docker only)
   --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
@@ -64,6 +68,8 @@ Options:
   --cleanup-dry-run     Show stale records that would be cleaned up (without cleaning)
   --cleanup <id>        Remove a Docker execution's containers and snapshot images (never forced)
   --cleanup-dry-run <id>  Show the containers and images --cleanup <id> would remove
+  --alias <id> <name>   Add a name the execution can be addressed by
+  --rename <id> <name>  Rename the execution, keeping its previous name as an alias
   --version, -v         Show version information
 
 Examples:
@@ -75,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
@@ -91,6 +98,9 @@ Examples:
   $ --resume my-docker-session             # Restart the stored command in the same container
   $ --resume my-docker-session -- bash     # Run a different command in the same container
   $ --resume-all                           # Re-attach every still-running execution
+  $ --session-id <uuid> --append-attempt -- npm test  # Next attempt, same log
+  $ --continues <uuid> -- npm test         # Fresh execution chained to <uuid>
+  $ --rename <uuid> nightly-build          # Address it as nightly-build from now on
   $ -i docker -d --on-kill-resume 3 --recovery-command 'solve --resume' -- solve
   $ -i docker -d --on-kill-resume 3 --on-kill-resume-delay 30-90 -- cargo test
   $ --use-command-stream echo "Hello"      # Use command-stream library`);

package/test/args-parser-attach-resume.js

@@ -142,7 +142,7 @@ describe('query mode exclusivity', () => {
     test(`rejects ${args.join(' ')}`, () => {
       assert.throws(() => {
         parse(args);
-      }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, or --cleanup/);
+      }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, --cleanup, --alias, or --rename/);
     });
   }
 });

package/test/args-parser-control.js

@@ -54,13 +54,13 @@ describe('control options', () => {
   it('should reject combining query and control modes', () => {
     assert.throws(() => {
       parseArgs(['--status', 'uuid-here', '--stop', 'my-session']);
-    }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, or --cleanup/);
+    }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, --cleanup, --alias, or --rename/);
   });
 
   it('should reject combining upload-log with control modes', () => {
     assert.throws(() => {
       parseArgs(['--upload-log', 'uuid-here', '--terminate', 'my-session']);
-    }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, or --cleanup/);
+    }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, --cleanup, --alias, or --rename/);
   });
 
   it('should reject output-format with control modes', () => {