@vodmal/vdx-cli 0.31.0 → 0.31.2

package/README.md

@@ -167,6 +167,7 @@ npm run typecheck
 - `src/mcp-server.ts` — MCP stdio server (9 tools)
 - `src/defaults.ts`   — bundled rubric resolution
 - `bin/vdx.cjs`, `bin/vdx-mcp.cjs` — Node wrappers (tsx ESM loader in-process)
+- `bin/node-guard.cjs` — under a project's older node (`.nvmrc` with fnm, nvm, mise), runs the wrapper again on the node beside its bin link
 
 ## Not implemented yet
 

package/bin/node-guard.cjs

@@ -0,0 +1,43 @@
+'use strict';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+// vdx needs Node 22 or newer (engines in package.json), and its bins start with
+// `env node`: in a project that pins an older node (.nvmrc under fnm or nvm,
+// mise) that is the project's node, and tsx stops before vdx starts. Then vdx
+// runs again on the node its bin link sits next to — the one whose npm put it
+// there; the project's node stays on PATH for the commands vdx runs. This file
+// runs on that old node: nothing past Node 14 in it.
+// True — the current node will do; false — the re-run or the error owns the exit.
+module.exports = function newEnoughNode(entry) {
+  if (Number(process.versions.node.split('.')[0]) >= 22) return true;
+  const node = real(path.join(path.dirname(process.argv[1]), 'node'));
+  if (!node || node === real(process.execPath)) {
+    console.error(
+      `vdx needs Node.js 22 or newer; the node on PATH here is ${process.version}` +
+        ' — the project may pin it (.nvmrc, .node-version, mise.toml)',
+    );
+    process.exitCode = 1;
+    return false;
+  }
+  const child = spawn(node, [entry].concat(process.argv.slice(2)), { stdio: 'inherit' });
+  // Ctrl-C reaches the child from the terminal itself; a signal sent to vdx alone is passed on.
+  ['SIGINT', 'SIGQUIT'].forEach((sig) => process.on(sig, () => {}));
+  ['SIGTERM', 'SIGHUP'].forEach((sig) => process.on(sig, () => child.kill(sig)));
+  child.on('error', (err) => {
+    console.error(`vdx: ${node}: ${err.message}`);
+    process.exit(1);
+  });
+  child.on('exit', (code, signal) => process.exit(signal ? 128 + os.constants.signals[signal] : code));
+  return false;
+};
+
+function real(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return null;
+  }
+}

package/bin/vdx-mcp.cjs

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 'use strict';
-const path = require('node:path');
-const { register } = require('tsx/esm/api');
-register();
-import(path.join(__dirname, '..', 'src', 'mcp-server.ts')).catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+if (require('./node-guard.cjs')(__filename)) {
+  const path = require('node:path');
+  const { register } = require('tsx/esm/api');
+  register();
+  import(path.join(__dirname, '..', 'src', 'mcp-server.ts')).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}

package/bin/vdx.cjs

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 'use strict';
-const path = require('node:path');
-const { register } = require('tsx/esm/api');
-register();
-import(path.join(__dirname, '..', 'src', 'index.ts')).catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+if (require('./node-guard.cjs')(__filename)) {
+  const path = require('node:path');
+  const { register } = require('tsx/esm/api');
+  register();
+  import(path.join(__dirname, '..', 'src', 'index.ts')).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodmal/vdx-cli",
-  "version": "0.31.0",
+  "version": "0.31.2",
   "description": "vdx — unified lifecycle interface (up/down/build/test/check/fix) + versioned maturity audit with drift detection. Pairs with the vdx Claude Code plugin.",
   "keywords": [
     "vdx",

package/src/ai.ts

@@ -292,6 +292,20 @@ export function renderSessionName(template: string, vars: Record<string, string>
   return name.replace(/[.:]/g, '_');
 }
 
+/**
+ * The session for an agent started next to running ones: `name`, `name-2`, `name-3`… — the
+ * first no agent of the project runs in (absent, or a shell left behind). Each agent has a
+ * session of its own: tmux keeps one current window per session, and an agent started as a
+ * window next to another moved every terminal on the session to it (vdx-ai DL #36).
+ */
+export function freeSessionName(name: string, running: { pane: { session: string } }[]): string {
+  const busy = new Set(running.map((a) => a.pane.session));
+  for (let n = 1; ; n++) {
+    const candidate = n === 1 ? name : `${name}-${n}`;
+    if (!busy.has(candidate)) return candidate;
+  }
+}
+
 export interface LaunchPlan {
   projectRoot: string;
   project: string;
@@ -804,7 +818,9 @@ function renderPlan(
   plan: LaunchPlan,
   multiplexer: Multiplexer,
   running: AgentPane[],
-  focusedOf: (pid: number) => boolean = () => false,
+  focusedOf: (pid: number) => boolean,
+  /** The session a start would make: next to running agents, one of its own. */
+  session: string,
 ): string {
   const lines = [
     `vdx ai — ${plan.projectRoot}`,
@@ -819,7 +835,7 @@ function renderPlan(
   for (const c of plan.confirm) lines.push(`  confirm:  "${c.screen}" → ${c.keys.join(' ')}`);
   lines.push(
     multiplexer === 'tmux'
-      ? `  session:  tmux; a new session is named "${plan.sessionName}"`
+      ? `  session:  tmux; a new session is named "${session}"`
       : '  session:  this terminal (no tmux)',
   );
   if (multiplexer === 'tmux') {
@@ -1618,7 +1634,9 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     ? foldersWarning(denied, multiplexer === 'tmux', environment.session?.folders_fix, deps.home)
     : [];
   if (opts.dryRun) {
-    deps.out(renderPlan(plan, multiplexer, running, focusedOf));
+    deps.out(
+      renderPlan(plan, multiplexer, running, focusedOf, freeSessionName(plan.sessionName, alongside ? running : [])),
+    );
     for (const l of choice?.lines ?? []) deps.out(`  conversation: ${l}\n`);
     for (const l of folders) deps.out(`  ${l}\n`);
     ensureAuthor(projectRoot, poolDirs, deps, true);
@@ -1758,10 +1776,9 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
   if (opts.restart) log(`note: no running ${plan.command} in this project — starting one`);
   const line = agentLine(plan, [...plan.args, ...plan.resumeArgs]);
   const cmd = tmuxShellCommand(line, deps.shell);
-  const reuse = tmux.hasSession(plan.sessionName);
-  const paneId = reuse
-    ? tmux.newWindow(plan.sessionName, projectRoot, cmd)
-    : tmux.newSession(plan.sessionName, projectRoot, cmd);
-  log(`▶ ${plan.sessionName}${reuse ? ' (new window)' : ''}: ${line}`);
-  return finish(settleResumed(plan, paneId, deps), plan.sessionName, paneId, opts, deps);
+  const session = freeSessionName(plan.sessionName, running);
+  const reuse = tmux.hasSession(session);
+  const paneId = reuse ? tmux.newWindow(session, projectRoot, cmd) : tmux.newSession(session, projectRoot, cmd);
+  log(`▶ ${session}${reuse ? ' (new window)' : ''}: ${line}`);
+  return finish(settleResumed(plan, paneId, deps), session, paneId, opts, deps);
 }

package/src/gate.ts

@@ -132,15 +132,18 @@ export function pushThroughGate(t: GateTarget, d: GateDeps): void {
     d.log(`✓ ${where} is at ${short}`);
   };
 
-  // Pushed once and checked: the branch takes it now.
-  const before = ask();
-  if (!isUnknown(before) && passed(before)) {
-    d.log(`✓ ${short} has passed ${names}`);
-    toBranch();
-    return;
+  const gate = GATE_PREFIX + t.branch;
+  // On the gate branch already (a second vdx push) and checked: the branch takes it now.
+  // A commit not pushed yet is not asked about — GitHub would only answer 422.
+  if (d.io.git(['rev-parse', '--verify', '--quiet', `refs/remotes/${t.remote}/${gate}`]) === sha) {
+    const before = ask();
+    if (!isUnknown(before) && passed(before)) {
+      d.log(`✓ ${short} has passed ${names}`);
+      toBranch();
+      return;
+    }
   }
 
-  const gate = GATE_PREFIX + t.branch;
   d.log(`→ git push --force ${t.remote} ${short}:${gate} — ${where} requires ${names}; CI checks the commit there`);
   d.push(['push', '--force', t.remote, `${sha}:refs/heads/${gate}`]);
   d.log(`→ waiting for ${names} on ${short} (asking every ${Math.round(d.pollMs / 1000)} s): ${link}`);

package/src/hosting.ts

@@ -228,6 +228,11 @@ export function commitChecks(
   token: string | null,
 ): CheckState[] | Unknown {
   const runs = io.get(`/repos/${repo}/commits/${sha}/check-runs?per_page=100`, token);
+  // Seconds after a push GitHub may not show the commit yet: 422 «No commit found
+  // for SHA» for 106da5f, 15 s after its push to a new branch (2026-10-18).
+  if (runs.status === 422 && /^No commit found/.test(str(at(runs.body, 'message')) ?? '')) {
+    return names.map((name) => ({ name, state: 'pending', detail: 'not on GitHub yet' }));
+  }
   const refusedRuns = refusal(runs, repo, token);
   if (refusedRuns) return refusedRuns;
   // A re-run is a new check run under the same name: the newest one counts.

package/src/index.ts

@@ -83,7 +83,7 @@ the project's files). Hand a person \`vdx ai\`, not \`<agent> --<flag>\`.
   @host         the same command on <host> over ssh: its vdx, profile and tmux
   --new         a new conversation instead of continuing the last one; an agent
                 already running here keeps running, the new one starts next to
-                it (a new tmux window)
+                it, in a tmux session of its own (<name>-2, -3, …)
   --focused     a new conversation, as --new, in a session nothing wakes: the
                 agent, its hooks and MCP servers get VDX_FOCUSED=1 — for the
                 plugins that wake sessions to leave it alone — and the profile's