@vodmal/vdx-cli 0.34.0 → 0.36.0

package/README.md

@@ -54,8 +54,9 @@ vdx doctor --check [project-path]   # one line per hook declared but not running
 vdx doctor --fix                    # write the profile's personal hooks (git.hooks) into ~/.gitconfig
 
 # Start your agent in a project per your profile (~/.vdx-environment.yaml or $VDX_ENVIRONMENT)
-vdx ai[@host] [project-path] [--new | --conversation <id>] [--focused] [--restart] [--detach] [--dry-run]   # default: cwd; @host: over ssh, in tmux there
-vdx ai --check [project-path]   # this session against the profile — what the plugin's SessionStart hook tells the agent
+vdx ai[@host] [project-path] [--new | --conversation <id>] [--focused | --intercom] [--restart] [--detach] [--dry-run]   # default: cwd; @host: over ssh, in tmux there; --intercom: the project's mail session
+vdx ai --close [--waiting <n>]   # inside the mail session: it ends itself; n questions to you still unanswered show on the project's other tmux sessions
+vdx ai --check [project-path]   # this session against the profile and the installed Claude Code and plugins — what the plugin's SessionStart hook tells the agent
 
 # What a command does and takes; nothing runs (ai: also where launch flags live)
 vdx <command> --help
@@ -79,6 +80,7 @@ vdx test            # → mise run test (which calls `vitest run` or whatever wa
 
 # 3. Ship a new minor release of a Node lib
 vdx publish minor   # npm login if expired → bump package.json + lock → npm publish (OTP or browser) → commit + tag → push → wait for the registry
+                    # in your own terminal: without one it releases nothing (--force goes on)
 
 # 4. Start the agent here, continuing its last conversation (--new: a new one,
 #    next to a running agent; another machine's conversation is continued on
@@ -143,6 +145,9 @@ the one git keeps for that host (`git credential fill`, never a prompt — log i
 once with `git ls-remote https://<host>/scm/<project>/<repo>.git`, a personal
 access token as the password), or `BITBUCKET_TOKEN` when the host is
 `BITBUCKET_HOST`. Branch restrictions are visible to a repository admin only.
+A login the server refuses (a revoked token) is unknown with the command that
+erases it: vdx leaves git's store alone, and sends the login again each audit
+until it is gone.
 Not met comes with the reason; another hosting, no network or no token
 where one is needed leave the axis unknown, with the reason too;
 `VDX_OFFLINE=1` does not ask at all.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodmal/vdx-cli",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "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/rubric/vdx-rubric.yaml

@@ -11,7 +11,7 @@ schema_version: "0.3"
 
 metadata:
   name: vdx-rubric-vodmal
-  version: "1.5.0"
+  version: "1.6.1"
   description: "Personal maturity rubric for multi-stack projects (vodmal)"
   owner: vodmal
   homepage: "https://github.com/vodmal/vdx-rubric"
@@ -260,8 +260,9 @@ axes:
     default_target: L4
     fact_sources: [hosting API]
     # Гейт — свойство L3 общей лестницы; ниже ось ничего не требует и уровень
-    # не ограничивает. Знает о защите только хостинг: пока расширения для него
-    # нет, L3 — «неизвестно» у всех. L4 — позже: force-push, удаление ветки,
+    # не ограничивает. Знает о защите только хостинг: vdx спрашивает GitHub
+    # (с CLI 0.29), GitLab (0.33) и Bitbucket Server (0.34), у другого хостинга
+    # L3 — «неизвестно» с причиной. L4 — позже: force-push, удаление ветки,
     # ревью (как Branch-Protection у Scorecard).
     levels:
       L1: { not_required: true }

package/src/ai.ts

@@ -22,6 +22,7 @@ import {
   liveConversationId,
   liveSessionsHere,
   liveStartedAt,
+  MAIL_LINE_PREFIX,
   machineLine,
   type MachineReport,
   machineOf,
@@ -29,6 +30,7 @@ import {
   runsInProject,
 } from './conversations.ts';
 import { at, errorMessage, isStringList, str } from './narrow.ts';
+import { type Lag, sessionLag } from './session-versions.ts';
 
 /**
  * `vdx ai` — start the person's agent in a project, with the flags their
@@ -68,6 +70,8 @@ export interface AgentProfile {
   command: string;
   args?: string[];
   resume_args?: string[];
+  /** What a mail session (`vdx ai --intercom`) starts with, right after the command: its first prompt. */
+  intercom_args?: string[];
   when?: WhenRule[];
 }
 
@@ -130,6 +134,16 @@ const SEAT_ENV_VAR = 'VDX_AI_FROM';
  * its hooks and MCP servers: nothing wakes this session or reads its inbox for it.
  */
 const FOCUSED_ENV_VAR = 'VDX_FOCUSED';
+/**
+ * `1` in the environment of the project's mail session (`vdx ai --intercom`): the
+ * session letters and wakes go to, so that the person's own session stays quiet.
+ * Nobody sits at it; it ends itself with `vdx ai --close`.
+ */
+const INTERCOM_ENV_VAR = 'VDX_INTERCOM';
+/** The tmux session option `vdx ai --close --waiting <n>` sets: questions to the person still unanswered. */
+const WAITING_OPTION = '@vdx_waiting';
+/** A mail session's pane closes this long after `--close`, so the call returns and the turn ends. */
+const CLOSE_DELAY_S = 2;
 const USER_ENVIRONMENT_FILE = '.vdx-environment.yaml';
 /** Tried in order when no profile names an agent. Started plain, with no flags. */
 const FALLBACK_AGENTS = ['claude', 'codex'] as const;
@@ -163,7 +177,7 @@ export function parseEnvironment(text: string, source: string): Environment {
     if (typeof agent.command !== 'string' || agent.command.trim() === '') {
       fail('agent.command', 'must be a non-empty string');
     }
-    for (const key of ['args', 'resume_args'] as const) {
+    for (const key of ['args', 'resume_args', 'intercom_args'] as const) {
       if (agent[key] !== undefined && !isStringList(agent[key])) {
         fail(`agent.${key}`, 'must be a list of strings');
       }
@@ -324,6 +338,10 @@ export interface LaunchPlan {
   focused: boolean;
   /** Matched rules a focused session leaves out (`wakes: true`). */
   skipped: string[];
+  /** `vdx ai --intercom`: the project's mail session — VDX_INTERCOM=1, a session `<name>-mail`. */
+  intercom: boolean;
+  /** agent.intercom_args: what a mail session starts with; not required of a running agent. */
+  intercomArgs: string[];
   confirm: ConfirmRule[];
   multiplexer: Multiplexer;
   sessionName: string;
@@ -341,9 +359,11 @@ export function planLaunch(input: {
   host: string;
   seat?: string;
   focused?: boolean;
+  intercom?: boolean;
 }): LaunchPlan {
   const { environment, agent, projectRoot } = input;
   const focused = input.focused === true;
+  const intercom = input.intercom === true && !focused;
   const ctx: Ctx = { projectRoot, stack: autoDetectStack(projectRoot), cache: new Map() };
   const args = [...(agent.args ?? [])];
   const matched: string[] = [];
@@ -372,12 +392,15 @@ export function planLaunch(input: {
     matched,
     focused,
     skipped,
+    intercom,
+    intercomArgs: intercom ? [...(agent.intercom_args ?? [])] : [],
     confirm,
     multiplexer: environment.session?.multiplexer ?? 'none',
-    sessionName: renderSessionName(environment.session?.name ?? DEFAULT_SESSION_NAME, {
-      project: input.project,
-      host: input.host,
-    }),
+    sessionName:
+      renderSessionName(environment.session?.name ?? DEFAULT_SESSION_NAME, {
+        project: input.project,
+        host: input.host,
+      }) + (intercom ? '-mail' : ''),
     machines: (environment.session?.machines ?? []).filter((m) => m.toLowerCase() !== input.host.toLowerCase()),
   };
 }
@@ -394,12 +417,13 @@ export function commandLine(command: string, args: string[]): string {
 /**
  * The pane runs the agent inside the user's login shell, so the agent sees what
  * `.zshrc` sets up exactly as when it is typed by hand; the tmux server's own
- * environment does not have it. When the agent exits, the pane keeps a shell.
+ * environment does not have it. When the agent exits, the pane keeps a shell —
+ * unless `keepShell` is false (a mail session: its tab goes when it is done).
  */
-export function tmuxShellCommand(line: string, shell: string | null): string {
+export function tmuxShellCommand(line: string, shell: string | null, keepShell = true): string {
   if (!shell) return line;
   const sh = shellQuote(shell);
-  return `exec ${sh} -lic ${shellQuote(`${line}; exec ${sh} -l`)}`;
+  return `exec ${sh} -lic ${shellQuote(keepShell ? `${line}; exec ${sh} -l` : line)}`;
 }
 
 export interface PaneInfo {
@@ -722,6 +746,8 @@ export interface AiOptions {
   dryRun: boolean;
   /** `--focused`: a session nothing wakes — VDX_FOCUSED=1, the profile's `wakes` rules left out. */
   focused?: boolean;
+  /** `--intercom`: the project's mail session — VDX_INTERCOM=1, one per project and machine. */
+  intercom?: boolean;
 }
 
 export interface AiDeps {
@@ -737,6 +763,8 @@ export interface AiDeps {
   processes: () => ProcInfo[];
   /** Was this agent process started focused; default: its environment (`processFocused`). */
   agentFocused?: (pid: number) => boolean;
+  /** Is this agent process a mail session; default: its environment (`processMode`). */
+  agentMail?: (pid: number) => boolean;
   /** Default `process.platform`: the folder check is for macOS. */
   platform?: NodeJS.Platform;
   sleep: (ms: number) => void;
@@ -749,6 +777,28 @@ export interface AiDeps {
   ssh?: (args: string[], capture: boolean) => { status: number; stdout: string } | null;
   /** Claude Code processes alive on this machine; read from its session files when not given. */
   liveHere?: () => LiveSession[];
+  /** What the agent process `pid` lags behind; read from Claude Code's files when not given. */
+  lag?: (pid: number, projectRoot: string, command: string) => Lag | null;
+}
+
+function machineLag(deps: AiDeps, pid: number, projectRoot: string, command: string): Lag | null {
+  return sessionLag({
+    env: deps.env,
+    home: deps.home,
+    pid,
+    projectRoot,
+    installedClaude: () => {
+      try {
+        return execFileSync(command, ['--version'], {
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'ignore'],
+          timeout: 5_000,
+        });
+      } catch {
+        return null;
+      }
+    },
+  });
 }
 
 function runSsh(args: string[], capture: boolean): { status: number; stdout: string } | null {
@@ -821,6 +871,8 @@ function renderPlan(
   focusedOf: (pid: number) => boolean,
   /** The session a start would make: next to running agents, one of its own. */
   session: string,
+  /** The project's agents this start leaves alone: the mail session for the others, the others for it. */
+  aside: AgentPane[] = [],
 ): string {
   const lines = [
     `vdx ai — ${plan.projectRoot}`,
@@ -832,6 +884,12 @@ function renderPlan(
   ];
   if (plan.focused)
     lines.push(`  focused:  nothing wakes it; left out: ${plan.skipped.length ? plan.skipped.join(', ') : '—'}`);
+  if (plan.intercom)
+    lines.push(
+      `  mail:     the project's mail session, a new conversation; first: ${
+        plan.intercomArgs.length ? plan.intercomArgs.join(' ') : '— (no agent.intercom_args: it waits for a wake)'
+      }`,
+    );
   for (const c of plan.confirm) lines.push(`  confirm:  "${c.screen}" → ${c.keys.join(' ')}`);
   lines.push(
     multiplexer === 'tmux'
@@ -849,6 +907,11 @@ function renderPlan(
         }${focused ? ', focused' : plan.focused ? ', not focused' : ''}`,
       );
     }
+    for (const a of aside) {
+      lines.push(
+        `  aside:    ${a.pane.session} ${a.pane.paneId} — ${plan.intercom ? 'not the mail session' : 'the mail session'}, left alone`,
+      );
+    }
   }
   return lines.join('\n') + '\n';
 }
@@ -951,7 +1014,7 @@ function settleResumed(plan: LaunchPlan, paneId: string, deps: AiDeps): boolean
   if (result !== 'not-running' || plan.resumeArgs.length === 0) return result === 'ok';
   const line = agentLine(plan, plan.args);
   deps.log(`↻ nothing to resume — starting without ${plan.resumeArgs.join(' ')}: ${line}`);
-  deps.tmux.respawn(paneId, plan.projectRoot, tmuxShellCommand(line, deps.shell));
+  deps.tmux.respawn(paneId, plan.projectRoot, tmuxShellCommand(line, deps.shell, !plan.intercom));
   return settle(plan, paneId, deps) === 'ok';
 }
 
@@ -996,6 +1059,7 @@ export function remoteAiArgs(input: {
   const flags = [
     opts.fresh && '--new',
     opts.focused && '--focused',
+    opts.intercom && '--intercom',
     opts.restart && '--restart',
     opts.detach && '--detach',
     opts.dryRun && '--dry-run',
@@ -1156,10 +1220,11 @@ function chooseConversation(plan: LaunchPlan, deps: AiDeps, canAsk: boolean): Co
   if (!isClaude(plan.command)) return { args: plan.resumeArgs, lines: [] };
   const host = plan.host;
   const same = sameMachine;
+  // A mail session's conversations are its own: a start of the person's never continues one.
   const all =
     plan.resumeArgs.length === 0
       ? []
-      : listConversations({ env: deps.env, home: deps.home, projectRoot: plan.projectRoot });
+      : listConversations({ env: deps.env, home: deps.home, projectRoot: plan.projectRoot }).filter((c) => !c.mail);
   const root = shellQuote(plan.projectRoot);
   // Said from where the person sits: under `vdx ai@<host>` that is not this machine.
   const atSeat = same(plan.seat, host);
@@ -1351,7 +1416,7 @@ interface Prepared {
 }
 
 /** The project, the profile and the launch plan for `pathArg`; an exit code when there is none. */
-function prepare(pathArg: string, deps: AiDeps, focused = false): Prepared | number {
+function prepare(pathArg: string, deps: AiDeps, focused = false, intercom = false): Prepared | number {
   const { log } = deps;
 
   const projectRoot = resolveProjectRoot(pathArg);
@@ -1400,6 +1465,7 @@ function prepare(pathArg: string, deps: AiDeps, focused = false): Prepared | num
       host: hostLabel(deps.env),
       seat: seatLabel(deps.env),
       focused: asFocused,
+      intercom,
     });
   let plan: LaunchPlan;
   try {
@@ -1411,20 +1477,35 @@ function prepare(pathArg: string, deps: AiDeps, focused = false): Prepared | num
   return { projectRoot, environment, profilePath, profileDir, plan, replan };
 }
 
-/** Was the process started focused — VDX_FOCUSED=1 in its environment (`ps -E` on macOS, /proc on Linux)? */
-export function processFocused(pid: number): boolean {
-  const mark = `${FOCUSED_ENV_VAR}=1`;
+/** How an agent process was started: `vdx ai --focused`, `vdx ai --intercom`, or neither. */
+export type AgentMode = 'focused' | 'mail' | 'plain';
+
+/**
+ * The mode from the process's environment (`ps -E` on macOS, /proc on Linux). Both marks —
+ * focused: deaf wins, as intercom reads it.
+ */
+export function processMode(pid: number): AgentMode {
+  let words: string[];
   try {
     const environ = `/proc/${pid}/environ`;
-    if (fs.existsSync(environ)) return fs.readFileSync(environ, 'utf8').split('\0').includes(mark);
-    const out = execFileSync('ps', ['-E', '-ww', '-o', 'command=', '-p', String(pid)], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    });
-    return out.split(/\s+/).includes(mark);
+    if (fs.existsSync(environ)) words = fs.readFileSync(environ, 'utf8').split('\0');
+    else {
+      const out = execFileSync('ps', ['-E', '-ww', '-o', 'command=', '-p', String(pid)], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+      words = out.split(/\s+/);
+    }
   } catch {
-    return false;
+    return 'plain';
   }
+  if (words.includes(`${FOCUSED_ENV_VAR}=1`)) return 'focused';
+  return words.includes(`${INTERCOM_ENV_VAR}=1`) ? 'mail' : 'plain';
+}
+
+/** Was the process started focused — VDX_FOCUSED=1 in its environment? */
+export function processFocused(pid: number): boolean {
+  return processMode(pid) === 'focused';
 }
 
 /** macOS guards these folders on their own; a tmux server can hold a denial for every session under it. */
@@ -1481,9 +1562,23 @@ export function foldersWarning(denied: string[], viaTmux: boolean, fix: string |
   ];
 }
 
-/** The agent's command line; a focused one carries VDX_FOCUSED=1 in front, for the shell in its tmux pane. */
+/**
+ * The agent's argv after the command. A mail session's intercom_args go first: its first
+ * prompt after `--dangerously-load-development-channels <servers...>` would be read as a server.
+ */
+function launchArgs(plan: LaunchPlan, args: string[]): string[] {
+  return [...plan.intercomArgs, ...args];
+}
+
+/** The mark of the agent's mode in its environment, if any: `VDX_FOCUSED` or `VDX_INTERCOM`. */
+function modeEnvVar(plan: LaunchPlan): string | null {
+  return plan.focused ? FOCUSED_ENV_VAR : plan.intercom ? INTERCOM_ENV_VAR : null;
+}
+
+/** The agent's command line; its mode's mark goes in front, for the shell in its tmux pane. */
 function agentLine(plan: LaunchPlan, args: string[]): string {
-  return `${plan.focused ? `${FOCUSED_ENV_VAR}=1 ` : ''}${commandLine(plan.command, args)}`;
+  const mark = modeEnvVar(plan);
+  return `${mark ? `${mark}=1 ` : ''}${commandLine(plan.command, launchArgs(plan, args))}`;
 }
 
 /** The nearest ancestor of `pid` that is the agent: the session a hook or a shell tool runs in. */
@@ -1504,12 +1599,14 @@ export function findOwnAgent(procs: ProcInfo[], pid: number, command: string): P
  */
 export function runAiCheck(pathArg: string, deps: AiDeps, selfPid: number = process.pid): number {
   if (!resolveEnvironmentPath(deps.env, deps.home)) return EXIT_OK;
-  // The hook runs in the agent's environment: a focused session's carries VDX_FOCUSED=1.
+  // The hook runs in the agent's environment: a focused session's carries VDX_FOCUSED=1,
+  // a mail session's VDX_INTERCOM=1.
   const focused = deps.env[FOCUSED_ENV_VAR] === '1';
-  const prepared = prepare(pathArg, deps, focused);
+  const intercom = !focused && deps.env[INTERCOM_ENV_VAR] === '1';
+  const prepared = prepare(pathArg, deps, focused, intercom);
   if (typeof prepared === 'number') return prepared;
   const { projectRoot, profilePath, plan } = prepared;
-  const vdxAi = `vdx ai${focused ? ' --focused' : ''}`;
+  const vdxAi = `vdx ai${focused ? ' --focused' : intercom ? ' --intercom' : ''}`;
 
   const lines = [
     `${machineLine(plan.host)}; the agent in this project is started with \`vdx ai\`, and its flags come from the profile ` +
@@ -1526,6 +1623,17 @@ export function runAiCheck(pathArg: string, deps: AiDeps, selfPid: number = proc
         '.',
     );
   }
+  if (intercom) {
+    // The conversation is known by this line as a mail session's (conversations.ts): keep its opening.
+    lines.push(
+      `${MAIL_LINE_PREFIX} (\`vdx ai --intercom\`): letters and wakes for the project come here, so the user's ` +
+        `own session stays quiet, and nobody sits at this one. When nothing is left for it — right after a check ` +
+        `of its inbox shows nothing to take — it ends itself: \`vdx ai --close\` (the pane closes ${CLOSE_DELAY_S} s ` +
+        `later, so say what was done first). With questions to the user still unanswered: ` +
+        `\`vdx ai --close --waiting <n>\` — the project's other tmux sessions here show the number; a plain ` +
+        `\`--close\` clears it.`,
+    );
+  }
   const own = findOwnAgent(deps.processes(), selfPid, plan.command);
   if (!own) {
     lines.push(`· no ${plan.command} among the ancestors of this process — no session to compare with the profile.`);
@@ -1534,35 +1642,132 @@ export function runAiCheck(pathArg: string, deps: AiDeps, selfPid: number = proc
   }
   const missing = missingArgs(own.args, plan.args);
   const why = plan.matched.length ? ` (profile conditions met here: ${plan.matched.join(', ')})` : '';
-  if (missing.length === 0) {
+  // A live session keeps the Claude Code and plugins it started with (vdx-ai, Sidetrack #24).
+  const lag = (deps.lag ?? ((pid, root, command) => machineLag(deps, pid, root, command)))(
+    own.pid,
+    projectRoot,
+    plan.command,
+  );
+  if (missing.length === 0 && !lag) {
     lines.push(`✓ this session carries the profile's flags${why}.`);
     deps.out(lines.join('\n') + '\n');
     return EXIT_OK;
   }
+  const problems: string[] = [];
+  if (missing.length > 0) problems.push(`✗ this session runs without ${missing.join(' ')}${why}.`);
+  else lines.push(`✓ this session carries the profile's flags${why}.`);
+  if (lag) problems.push(`✗ ${describeLag(lag)}.`);
+
   const root = shellQuote(projectRoot);
-  lines.push(
-    `✗ this session runs without ${missing.join(' ')}${why}. Hand the user the fix — ` +
+  const again = [
+    missing.length > 0 ? " with the profile's flags" : '',
+    lag ? `${missing.length > 0 ? ',' : ''} on the installed Claude Code and plugins` : '',
+  ].join('');
+  // Plugins alone: /reload-plugins loads them and the conversation goes on in the same process.
+  const reload =
+    missing.length === 0 && lag && !lag.claude
+      ? '`/reload-plugins`: it loads the installed plugins and keeps the conversation (Claude Code stays as it is); or '
+      : '';
+  problems.push(
+    `Hand the user the fix — ${reload}` +
       (deps.env['TMUX']
-        ? `\`${vdxAi} --restart ${root}\`: it stops this session and starts it again with the profile's flags` +
-          (plan.resumeArgs.length ? `, resuming the conversation (${plan.resumeArgs.join(' ')})` : '') +
+        ? `\`${vdxAi} --restart ${root}\`: it stops this session and starts it again${again}` +
+          // A focused session and the mail session restart into a new conversation.
+          (focused || intercom
+            ? ', in a new conversation'
+            : plan.resumeArgs.length
+              ? `, resuming the conversation (${plan.resumeArgs.join(' ')})`
+              : '') +
           `. Do not run it yourself: it ends this session.`
         : `this session runs outside tmux, so vdx cannot restart it: the user exits it and runs \`${vdxAi} ${root}\`.`),
   );
+  lines.push(problems.join(' '));
   deps.out(lines.join('\n') + '\n');
   return EXIT_DRIFT;
 }
 
+/**
+ * `vdx ai --close [--waiting <n>]`: the mail session ends itself — run inside it, by its
+ * agent. Only the pane whose agent is this process's own ancestor and carries VDX_INTERCOM=1
+ * is closed, a few seconds later: the command never ends the person's session. The project's
+ * other tmux sessions here get `@vdx_waiting` = n, the questions to the person still
+ * unanswered — the mail session's tab is about to go; without `--waiting`, none, and the
+ * mark is cleared: the last mail session's word holds.
+ */
+export function runAiClose(pathArg: string, waiting: number, deps: AiDeps, selfPid: number = process.pid): number {
+  const { log, tmux } = deps;
+  const prepared = prepare(pathArg, deps, false, true);
+  if (typeof prepared === 'number') return prepared;
+  const { projectRoot, plan } = prepared;
+  const procs = deps.processes();
+  const own = findOwnAgent(procs, selfPid, plan.command);
+  const mailOf = deps.agentMail ?? ((pid: number) => processMode(pid) === 'mail');
+  if (!own || !mailOf(own.pid)) {
+    log(
+      `vdx ai --close: this is not a mail session (\`vdx ai --intercom\`)` +
+        `${own ? '' : ` — no ${plan.command} among the ancestors of this process`}; nothing closed`,
+    );
+    return EXIT_USAGE;
+  }
+  const panes = tmux.panes();
+  const pane = panes.find((p) => processTree(procs, p.panePid).some((x) => x.pid === own.pid));
+  if (!pane) {
+    log('vdx ai --close: this mail session runs outside tmux — nothing to close here; it ends when its agent exits');
+    return EXIT_USAGE;
+  }
+  const others = [
+    ...new Set(findAgentPanes(panes, procs, projectRoot, plan.command).map((a) => a.pane.session)),
+  ].filter((s) => s !== pane.session);
+  for (const s of others) {
+    // `=name:` — a session option needs the session as a target, `=name` alone is not found.
+    tmux.tryRun(
+      waiting > 0
+        ? ['set-option', '-t', `=${s}:`, WAITING_OPTION, String(waiting)]
+        : ['set-option', '-u', '-t', `=${s}:`, WAITING_OPTION],
+    );
+  }
+  if (waiting > 0)
+    log(
+      others.length
+        ? `✓ ${waiting} waiting for the user — shown on ${others.join(', ')}`
+        : `note: ${waiting} waiting for the user, and no other session of this project here to show it`,
+    );
+  if (tmux.tryRun(['run-shell', '-b', '-d', String(CLOSE_DELAY_S), '-C', `kill-pane -t ${pane.paneId}`]) === null) {
+    log(`✗ ${pane.session} ${pane.paneId}: tmux did not take the close — the mail session keeps running`);
+    return EXIT_LAUNCH_FAILED;
+  }
+  log(`✓ ${pane.session} ${pane.paneId}: the mail session closes in ${CLOSE_DELAY_S} s`);
+  return EXIT_OK;
+}
+
+/** `this session runs Claude Code 2.1.294 — 2.1.304 is installed; plugins updated since it loaded them: vdm 2.54.0`. */
+function describeLag(lag: Lag): string {
+  const names = lag.plugins.map((p) => `${p.name} ${p.version}`).join(', ');
+  if (!lag.claude) return `plugins updated since this session loaded them: ${names} — it still runs the ones it loaded`;
+  const claude = `this session runs Claude Code ${lag.claude.runs} — ${lag.claude.installed} is installed`;
+  return lag.plugins.length > 0 ? `${claude}; plugins updated since it loaded them: ${names}` : claude;
+}
+
 export function runAi(opts: AiOptions, deps: AiDeps): number {
   const { log, tmux } = deps;
 
-  const prepared = prepare(opts.path, deps, opts.focused === true);
+  if (opts.intercom && opts.focused) {
+    log('vdx ai: --intercom and --focused are different sessions — the mail session, or one nothing wakes; pick one');
+    return EXIT_USAGE;
+  }
+  if (opts.intercom && opts.conversation) {
+    log('vdx ai: --intercom starts the mail session in a new conversation — it takes no --conversation');
+    return EXIT_USAGE;
+  }
+  const prepared = prepare(opts.path, deps, opts.focused === true, opts.intercom === true);
   if (typeof prepared === 'number') return prepared;
   const { projectRoot, environment, profileDir } = prepared;
   let { plan } = prepared;
   // The agent started here runs on this machine: it does not inherit where the person sat,
-  // and it is focused by this start's flag, not by the shell vdx runs in.
+  // and its mode is this start's flag, not the shell vdx runs in.
   delete deps.env[SEAT_ENV_VAR];
   delete deps.env[FOCUSED_ENV_VAR];
+  delete deps.env[INTERCOM_ENV_VAR];
   // Under `vdx ai@<host>` the person is not here: this machine goes by its name.
   const atSeat = sameMachine(plan.seat, plan.host);
   const here = atSeat ? `here, on ${plan.host}` : `on ${plan.host}`;
@@ -1571,8 +1776,9 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     log(`vdx ai: --conversation names a Claude Code conversation; the agent here is ${plan.command}`);
     return EXIT_USAGE;
   }
-  // A start continues the last conversation unless asked for a new one; a focused session is a new one.
-  const wantsNew = (opts.fresh || opts.focused === true) && !opts.conversation;
+  // A start continues the last conversation unless asked for a new one; a focused session and
+  // the mail session are new ones.
+  const wantsNew = (opts.fresh || opts.focused === true || plan.intercom) && !opts.conversation;
   if (wantsNew) plan = { ...plan, resumeArgs: [] };
 
   let multiplexer = plan.multiplexer;
@@ -1581,8 +1787,13 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     multiplexer = 'none';
   }
 
-  const running =
+  const agentsHere =
     multiplexer === 'tmux' ? findAgentPanes(tmux.panes(), deps.processes(), projectRoot, plan.command) : [];
+  // The mail session and the person's sessions do not see each other: --intercom is about the
+  // one mail session, every other start leaves it alone — nobody sits at it, and it ends itself.
+  const mailOf = deps.agentMail ?? ((pid: number) => processMode(pid) === 'mail');
+  const running = agentsHere.filter((a) => mailOf(a.proc.pid) === plan.intercom);
+  const aside = agentsHere.filter((a) => !running.includes(a));
   const focusedOf = deps.agentFocused ?? processFocused;
   const conversationOf = (a: AgentPane) => liveConversationId(deps.env, deps.home, a.proc.pid);
   // Which running agent the start is about. A new conversation, or one no agent here is in, starts
@@ -1590,8 +1801,14 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
   // one asked for: no second agent in it blindly.
   const inConversation = opts.conversation ? running.find((a) => conversationOf(a) === opts.conversation) : undefined;
   const unreadable = opts.conversation && !inConversation ? running.find((a) => conversationOf(a) === null) : undefined;
+  // One mail session per project and machine: a running one is the one, never a second next to it.
   const alongside =
-    running.length > 0 && !opts.restart && !inConversation && !unreadable && (wantsNew || !!opts.conversation);
+    !plan.intercom &&
+    running.length > 0 &&
+    !opts.restart &&
+    !inConversation &&
+    !unreadable &&
+    (wantsNew || !!opts.conversation);
   let current = inConversation ?? unreadable;
   if (!current && !alongside && running.length > 0) {
     const picked = pickAgent(running, focusedOf, deps, !opts.dryRun);
@@ -1611,7 +1828,9 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
   // What a start continues. A restart keeps the conversation the agent is in.
   let choice: ConversationChoice | null = null;
   if (!current || opts.restart) {
-    if (opts.conversation) choice = { args: resumeId(opts.conversation), lines: [] };
+    // The mail session runs next to the person's agents on any machine by design: nothing to ask.
+    if (plan.intercom) choice = { args: [], lines: [] };
+    else if (opts.conversation) choice = { args: resumeId(opts.conversation), lines: [] };
     // A restart into a new conversation replaces the agent here, and a new one next to an agent here
     // is what was asked for: the other machines are not asked.
     else if ((current || alongside) && plan.resumeArgs.length === 0) choice = { args: [], lines: [] };
@@ -1635,7 +1854,14 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     : [];
   if (opts.dryRun) {
     deps.out(
-      renderPlan(plan, multiplexer, running, focusedOf, freeSessionName(plan.sessionName, alongside ? running : [])),
+      renderPlan(
+        plan,
+        multiplexer,
+        running,
+        focusedOf,
+        freeSessionName(plan.sessionName, alongside ? running : []),
+        aside,
+      ),
     );
     for (const l of choice?.lines ?? []) deps.out(`  conversation: ${l}\n`);
     for (const l of folders) deps.out(`  ${l}\n`);
@@ -1686,9 +1912,14 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
       return EXIT_USAGE;
     }
     for (const c of plan.confirm) log(`note: the agent will ask "${c.screen}" — answer it with ${c.keys.join(' ')}`);
-    const env = plan.focused ? { ...process.env, [FOCUSED_ENV_VAR]: '1' } : undefined;
+    const mark = modeEnvVar(plan);
+    const env = mark ? { ...process.env, [mark]: '1' } : undefined;
     const startedAt = Date.now();
-    let res = spawnSync(plan.command, [...plan.args, ...plan.resumeArgs], { cwd: projectRoot, stdio: 'inherit', env });
+    let res = spawnSync(plan.command, launchArgs(plan, [...plan.args, ...plan.resumeArgs]), {
+      cwd: projectRoot,
+      stdio: 'inherit',
+      env,
+    });
     if (at(res.error, 'code') === 'ENOENT') {
       log(`vdx ai: \`${plan.command}\` not found on PATH`);
       return 127;
@@ -1696,7 +1927,7 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     const failedAtOnce = res.status !== null && res.status !== 0 && Date.now() - startedAt < NOTHING_TO_RESUME_MS;
     if (plan.resumeArgs.length > 0 && failedAtOnce) {
       log(`↻ nothing to resume — starting without ${plan.resumeArgs.join(' ')}: ${agentLine(plan, plan.args)}`);
-      res = spawnSync(plan.command, plan.args, { cwd: projectRoot, stdio: 'inherit', env });
+      res = spawnSync(plan.command, launchArgs(plan, plan.args), { cwd: projectRoot, stdio: 'inherit', env });
     }
     return res.status ?? 1;
   }
@@ -1719,20 +1950,20 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     const unfocused = plan.focused && !runningFocused;
     const missing = unfocused ? [] : missingArgs(current.proc.args, plan.args);
     if (!unfocused && missing.length === 0) {
-      log(
-        `✓ ${current.pane.session}: already running with the profile${runningFocused ? ', focused' : ''} — ${current.proc.args}`,
-      );
+      const mode = runningFocused ? ', focused' : plan.intercom ? ', the mail session' : '';
+      log(`✓ ${current.pane.session}: already running with the profile${mode} — ${current.proc.args}`);
       return finish(true, current.pane.session, current.pane.paneId, opts, deps);
     }
     // Drift. In a terminal the person picks: the agent as it runs, or a restart
     // with the profile; without one nothing is touched, and the fix is named.
     const drift = `${current.pane.session}: ${plan.command} is running${unfocused ? ', not focused' : ` without ${missing.join(' ')}`}`;
+    const modeFlag = plan.focused ? ' --focused' : plan.intercom ? ' --intercom' : '';
     const fix =
-      `vdx ai --restart${plan.focused ? ' --focused' : ''}${opts.fresh ? ' --new' : ''} ${shellQuote(projectRoot)}` +
+      `vdx ai --restart${modeFlag}${opts.fresh ? ' --new' : ''} ${shellQuote(projectRoot)}` +
       (opts.conversation ? ` --conversation ${opts.conversation}` : '');
     const effect = plan.resumeArgs.length
       ? 'stops the running agent, then resumes its conversation'
-      : opts.fresh
+      : opts.fresh || plan.intercom
         ? 'stops the running agent and starts a new conversation'
         : 'stops the running agent; the conversation is not resumed — the profile has no resume_args';
     if (!deps.interactive) {
@@ -1763,7 +1994,7 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
   if (current) {
     const line = agentLine(plan, [...plan.args, ...plan.resumeArgs]);
     log(`↻ ${current.pane.session} ${current.pane.paneId}: restarting — ${line}`);
-    tmux.respawn(current.pane.paneId, projectRoot, tmuxShellCommand(line, deps.shell));
+    tmux.respawn(current.pane.paneId, projectRoot, tmuxShellCommand(line, deps.shell, !plan.intercom));
     return finish(
       settleResumed(plan, current.pane.paneId, deps),
       current.pane.session,
@@ -1774,8 +2005,10 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
   }
 
   if (opts.restart) log(`note: no running ${plan.command} in this project — starting one`);
+  if (plan.intercom && plan.intercomArgs.length === 0)
+    log('note: the profile has no agent.intercom_args — the mail session starts idle and waits for a wake');
   const line = agentLine(plan, [...plan.args, ...plan.resumeArgs]);
-  const cmd = tmuxShellCommand(line, deps.shell);
+  const cmd = tmuxShellCommand(line, deps.shell, !plan.intercom);
   const session = freeSessionName(plan.sessionName, running);
   const reuse = tmux.hasSession(session);
   const paneId = reuse ? tmux.newWindow(session, projectRoot, cmd) : tmux.newSession(session, projectRoot, cmd);

package/src/conversations.ts

@@ -31,6 +31,8 @@ import { at, dict, str } from './narrow.ts';
 /** The opening of `vdx ai --check`'s text; the label is an ssh destination from the other machines. */
 const MACHINE_LINE_PREFIX = 'vdx ai: this machine is';
 const MACHINE_LINE_RE = /^vdx ai: this machine is `([^`]+)`/m;
+/** The opening of the line `vdx ai --check` adds in a mail session (`vdx ai --intercom`). */
+export const MAIL_LINE_PREFIX = "· this is the project's mail session";
 /** A label read from a synced file goes to ssh: it must not be able to read as an option. */
 const LABEL_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -58,6 +60,8 @@ export interface Conversation {
   typedHere: boolean;
   /** Claude's title for it, else the last prompt. */
   title: string | null;
+  /** Last started as the project's mail session (`vdx ai --intercom`): not the person's to continue. */
+  mail: boolean;
 }
 
 export function claudeConfigDir(env: NodeJS.ProcessEnv, home: string): string {
@@ -78,6 +82,7 @@ export function readConversation(file: string, updated: Date): Conversation | nu
     return null;
   }
   let machine: string | null = null;
+  let mail = false;
   let aiTitle: string | null = null;
   let lastPrompt: string | null = null;
   let turns = false;
@@ -102,13 +107,17 @@ export function readConversation(file: string, updated: Date): Conversation | nu
       const content = at(entry, 'attachment', 'content');
       for (const part of Array.isArray(content) ? (content as unknown[]) : [content]) {
         const label = typeof part === 'string' ? part.match(MACHINE_LINE_RE)?.[1] : undefined;
-        if (label && LABEL_RE.test(label)) machine = label;
+        if (label && LABEL_RE.test(label)) {
+          machine = label;
+          // The same text says whether that start was a mail session's.
+          mail = (part as string).includes(MAIL_LINE_PREFIX);
+        }
       }
     }
   }
   if (!turns) return null;
   const id = path.basename(file, '.jsonl');
-  return { id, updated, machine, typedHere: false, title: aiTitle ?? lastPrompt };
+  return { id, updated, machine, typedHere: false, title: aiTitle ?? lastPrompt, mail };
 }
 
 /** Which of `ids` had a prompt typed in them on this machine. */

package/src/hosting.ts

@@ -332,7 +332,7 @@ function judgeGitlab(io: HostingIo, host: string, repo: string, token: string |
 interface BitbucketAuth {
   token: string;
   scheme: 'Bearer' | 'Basic';
-  source: string;
+  source: 'BITBUCKET_TOKEN' | 'the login git keeps';
 }
 
 const MIN_BUILDS = 'com.atlassian.bitbucket.server.bitbucket-build:requiredBuildsMergeCheck';
@@ -340,14 +340,37 @@ const MIN_BUILDS = 'com.atlassian.bitbucket.server.bitbucket-build:requiredBuild
 /** A refusal of Bitbucket as the reason the answer is unknown; null for a 200. */
 function bitbucketRefusal(a: Answer, host: string, repo: string, auth: BitbucketAuth | null): Unknown | null {
   if (a.status === 200) return null;
-  const message = str(at(list(at(a.body, 'errors'))[0], 'message')) ?? '';
+  const error = list(at(a.body, 'errors'))[0];
+  const message = str(at(error, 'message')) ?? '';
+  const login = `git ls-remote https://${host}/scm/${repo}.git, a token as the password`;
   if (a.status === 401 && !auth) {
     return {
-      unknown: `${host} shows ${repo} only after a login — once: git ls-remote https://${host}/scm/${repo}.git, a token as the password; or BITBUCKET_TOKEN with BITBUCKET_HOST`,
+      unknown: `${host} shows ${repo} only after a login — once: ${login}; or BITBUCKET_TOKEN with BITBUCKET_HOST`,
     };
   }
-  if (a.status === 401) {
-    return { unknown: `${host} refused ${repo} to ${auth?.source} — no access, a changed password, a revoked token?` };
+  if (a.status === 401 && auth) {
+    // A login the server refused — a revoked token, a changed password — is an
+    // AuthenticationException; one it took, without access, an AuthorisationException,
+    // as is no login at all, and a Bearer token it does not know (git.finam.ru, 2026-10-22).
+    // vdx does not touch git's store: the owner erases the login (Sidetrack #11).
+    const exception = str(at(error, 'exceptionName')) ?? '';
+    if (
+      exception === 'com.atlassian.bitbucket.auth.IncorrectPasswordAuthenticationException' &&
+      auth.source !== 'BITBUCKET_TOKEN'
+    ) {
+      return {
+        unknown: `${host} refused the login git keeps for it, and every audit sends it again — each refusal brings the account nearer a CAPTCHA; erase it: printf 'protocol=https\\nhost=${host}\\n\\n' | git credential reject — and log in once more: ${login}`,
+      };
+    }
+    if (exception.endsWith('AuthenticationException')) {
+      return { unknown: `${host} refused ${auth.source}${message ? `: ${message}` : ''}` };
+    }
+    return {
+      unknown:
+        auth.source === 'BITBUCKET_TOKEN'
+          ? `${host} refused ${repo} to BITBUCKET_TOKEN — no access, or a token it does not know: it takes one for no login`
+          : `${host} refused ${repo} to the login git keeps — it has no access to the repository`,
+    };
   }
   return { unknown: `${host} answered ${a.status} for ${repo}${message ? `: ${message}` : ''}` };
 }

package/src/index.ts

@@ -35,7 +35,7 @@ import {
 } from './publish.ts';
 import { resolveDefaultRubric } from './defaults.ts';
 import { defaultGateDeps, GATE_PREFIX, planGate, pushThroughGate } from './gate.ts';
-import { askLine, runAi, runAiCheck, runAiRemote, defaultDeps, hostLabel, REMOTE_HOST_RE } from './ai.ts';
+import { askLine, runAi, runAiCheck, runAiClose, runAiRemote, defaultDeps, hostLabel, REMOTE_HOST_RE } from './ai.ts';
 import { isConversationId } from './conversations.ts';
 
 const DEFAULT_RUBRIC = resolveDefaultRubric();
@@ -90,18 +90,35 @@ the project's files). Hand a person \`vdx ai\`, not \`<agent> --<flag>\`.
                 rules marked \`wakes: true\` (a channel flag) are left out. Back
                 to it: --focused --conversation <id>. A running agent keeps its
                 mode: plain vdx ai attaches to it as it is
+  --intercom    the project's mail session: a new conversation in a tmux
+                session of its own (<name>-mail), one per project and machine —
+                a running one is attached to, never a second. The agent, its
+                hooks and MCP servers get VDX_INTERCOM=1: letters and wakes for
+                the project go there, and your own session stays quiet; the
+                profile's \`wakes\` rules stay. It starts with agent.intercom_args
+                (its first prompt). Every other start leaves it alone, and its
+                conversations are not continued unless named with --conversation.
+                Started by the agent that has a letter and nobody to wake:
+                vdx ai --intercom --detach <project>
+  --close [--waiting <n>]
+                inside the mail session: it ends itself — its pane closes 2 s
+                later. --waiting <n>: n questions to you still unanswered; the
+                project's other tmux sessions here get @vdx_waiting = n (without
+                it the mark is cleared). Anywhere else: refused, nothing closed
   --conversation <id>
                 continue this Claude Code conversation: attach to the agent in
                 it, or start one next to the agents running here
   --restart     restart the running agent in its pane — applies a changed profile;
-                with --new, --focused or --conversation, it is replaced by that.
+                with --new, --focused or --conversation, it is replaced by that;
+                with --intercom, the mail session gets a new conversation.
                 Without it, an agent running without the profile's flags is
                 a question in a terminal: Enter attaches to it as is, r
                 restarts it, q leaves it
   --detach      start without attaching; print the command that attaches
   --dry-run     print the plan and the project's running agents; start nothing
-  --check       for the agent's own session: how the agent here is launched, and
-                whether this session carries the profile's flags (the vdx plugin's
+  --check       for the agent's own session: how the agent here is launched,
+                whether this session carries the profile's flags, and whether it
+                runs the installed Claude Code and plugins (the vdx plugin's
                 SessionStart hook); prints nothing without a profile; exit 3 on drift
   -h, --help    this help
 
@@ -165,8 +182,9 @@ mise.toml is overwritten only with --force.
   Ctrl-C there stops only the wait).
 Nothing in the package's directory changed since the tag of its version: the
 same package under a new number — at a terminal a question, Enter releases nothing.
+Without a terminal it releases nothing: npm would ask for an OTP nobody sees.
 --dry-run runs the pre-flight and prints the plan; --force goes on past a failed
-pre-flight; --no-push leaves the commit and the tag local.
+pre-flight, and without a terminal; --no-push leaves the commit and the tag local.
 `,
     bools: ['dry-run', 'force', 'no-push'],
     positionals: 1,
@@ -217,11 +235,12 @@ Exit 2 when something is missing.
     positionals: 1,
   },
   ai: {
-    usage: 'vdx ai[@host] [project_path] [--new | --conversation <id>] [--focused] [--restart] [--detach] [--dry-run]',
+    usage:
+      'vdx ai[@host] [project_path] [--new | --conversation <id>] [--focused | --intercom] [--restart] [--detach] [--dry-run]',
     help: AI_HELP,
     // `--resume` asked to continue in 0.12; continuing is the default now.
-    bools: ['new', 'focused', 'restart', 'resume', 'detach', 'dry-run', 'check'],
-    values: ['conversation'],
+    bools: ['new', 'focused', 'intercom', 'restart', 'resume', 'detach', 'dry-run', 'check', 'close'],
+    values: ['conversation', 'waiting'],
     positionals: 1,
   },
   ...Object.fromEntries(
@@ -411,6 +430,18 @@ function cmdPublish(opts: ParsedArgs): void {
   const bump = bumpArg as BumpKind;
   const projectRoot = process.cwd();
 
+  // npm asks for an OTP or a confirmation in the browser, after the bump: without a
+  // terminal nobody answers. Claude Code's Bash tool has none, and `!` there moves a
+  // command past 120 s to the background (publish-npm-outage-preflight, 2026-10-22).
+  if (!opts.flags['dry-run'] && !opts.flags.force && process.stdin.isTTY !== true) {
+    process.stderr.write(
+      `vdx publish: no terminal here — npm asks for a one-time password or a confirmation in the browser, ` +
+        `and nobody could answer. Run it in your own terminal: vdx publish ${bump}. ` +
+        `--dry-run shows the plan; --force releases without a terminal (an automation token)\n`,
+    );
+    process.exit(2);
+  }
+
   const manifest = loadManifest(projectRoot);
   const overrides = loadOverrides(projectRoot);
   const rubric = loadRubric(DEFAULT_RUBRIC);
@@ -601,6 +632,27 @@ function cmdAi(opts: ParsedArgs): void {
     }
     process.exit(runAiCheck(opts.positionals[0] ?? '.', defaultDeps()));
   }
+  if (opts.flags.close === true || opts.flags.waiting !== undefined) {
+    // Run inside the mail session, about that session: nothing to start, no other machine.
+    const others = Object.keys(opts.flags).filter((f) => f !== 'close' && f !== 'waiting');
+    if (opts.flags.close !== true || others.length > 0 || opts.cmd !== 'ai') {
+      process.stderr.write(
+        opts.flags.close !== true
+          ? 'vdx ai: --waiting goes with --close\n'
+          : `vdx ai: --close takes only the project path and --waiting (not ${opts.cmd !== 'ai' ? opts.cmd : `--${others.join(', --')}`})\n`,
+      );
+      process.exit(2);
+    }
+    const raw = opts.flags.waiting;
+    const waiting = raw === undefined ? 0 : typeof raw === 'string' && /^\d+$/.test(raw) ? Number(raw) : NaN;
+    if (Number.isNaN(waiting)) {
+      process.stderr.write(
+        `vdx ai: --waiting takes the number of questions to the user (0, 1, 2…), not "${String(raw)}"\n`,
+      );
+      process.exit(2);
+    }
+    process.exit(runAiClose(opts.positionals[0] ?? '.', waiting, defaultDeps()));
+  }
   const conversation = typeof opts.flags.conversation === 'string' ? opts.flags.conversation : undefined;
   if (conversation !== undefined && !isConversationId(conversation)) {
     process.stderr.write(`vdx ai: --conversation takes a conversation id (a UUID), not "${conversation}"\n`);
@@ -618,6 +670,7 @@ function cmdAi(opts: ParsedArgs): void {
     detach: opts.flags.detach === true,
     dryRun: opts.flags['dry-run'] === true,
     focused: opts.flags.focused === true,
+    intercom: opts.flags.intercom === true,
   };
   const deps = { ...defaultDeps(), version: readCliVersion() };
   // `ai@m3`: the same command on another machine. Its own label runs here.

package/src/init.ts

@@ -6,7 +6,7 @@ import { at } from './narrow.ts';
 export const STANDARD_VERBS = ['up', 'down', 'build', 'test', 'check', 'fix'] as const;
 export type Verb = (typeof STANDARD_VERBS)[number];
 
-export const DEFAULT_BASELINE = 'github.com/VoDmAl/vdx-rubric-vodmal@v1.5.0';
+export const DEFAULT_BASELINE = 'github.com/VoDmAl/vdx-rubric-vodmal@v1.6.1';
 
 const VERB_ALIASES: Record<Verb, string[]> = {
   up: ['docker:up', 'docker-up', 'docker:up:detached', 'start', 'dev', 'serve'],

package/src/publish.ts

@@ -199,6 +199,17 @@ export function checkNpmAuth(registry: string | null, npm: NpmRunner): Preflight
         fix,
       };
     }
+    // A 5xx is the registry's trouble, not the login: 0.35.0 met E503 during an npm
+    // incident on 2026-10-22, and the line read as a failed login.
+    const outage = /\bE(5\d\d)\b/.exec(stderr);
+    if (outage) {
+      const npmjs = !registry || registry.includes('registry.npmjs.org');
+      return {
+        name: 'npm-auth',
+        ok: false,
+        message: `${where} is not answering (E${outage[1]}) — trouble on its side, not the login${npmjs ? '; status: https://status.npmjs.org' : ''}. Run vdx publish again once it answers`,
+      };
+    }
     return {
       name: 'npm-auth',
       ok: false,

package/src/session-versions.ts

@@ -0,0 +1,149 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { claudeConfigDir, projectDirName } from './conversations.ts';
+import { at, dict, list, str } from './narrow.ts';
+
+/**
+ * What a running Claude Code session lags behind: a live session keeps the
+ * Claude Code and the plugins it started with, and takes new ones only when it
+ * starts again or by `/reload-plugins` (docs/tasks/vdx-ai, Sidetrack #24).
+ * Read from Claude Code's own files — its session file, `installed_plugins.json`,
+ * the settings that enable a plugin, the transcript — which are its internals,
+ * not an API.
+ */
+export interface Lag {
+  /** Claude Code: the version the session runs and the one installed now; null when they agree. */
+  claude: { runs: string; installed: string } | null;
+  /** Enabled plugins updated after the session loaded its plugins: their name and the installed version. */
+  plugins: Array<{ name: string; version: string }>;
+}
+
+export interface LagInput {
+  env: NodeJS.ProcessEnv;
+  home: string;
+  /** The session's Claude Code process. */
+  pid: number;
+  projectRoot: string;
+  /** `claude --version` of the Claude Code a new start would run; null when it does not answer. */
+  installedClaude: () => string | null;
+  /** Default `Date.now()`. */
+  now?: number;
+}
+
+/**
+ * How long what a session loaded may stand before newer counts as a lag. On
+ * 2026-10-21 all 14 live sessions on lft were behind, an echelon release minutes
+ * old among them; the harm is a session that runs old code for days (twelve, in
+ * ai-dev-plugins' count). A day lets an update arrive without every session's
+ * next compaction calling for a reload.
+ */
+const LAG_AFTER_MS = 24 * 60 * 60 * 1000;
+
+/** What the session lags behind; null when nothing — or when its session file is not here to say. */
+export function sessionLag(input: LagInput): Lag | null {
+  const now = input.now ?? Date.now();
+  const config = claudeConfigDir(input.env, input.home);
+  const session = readJson(path.join(config, 'sessions', `${input.pid}.json`));
+  const startedAt = at(session, 'startedAt');
+  if (typeof startedAt !== 'number' || now - startedAt < LAG_AFTER_MS) return null;
+
+  const runs = str(at(session, 'version'));
+  const installed = versionOf(input.installedClaude());
+  const claude = runs && installed && newer(installed, runs) ? { runs, installed } : null;
+
+  let plugins = updatedPlugins(config, input.projectRoot).filter((p) => p.at > startedAt);
+  if (plugins.length > 0) {
+    // A /reload-plugins loaded what was installed then: the transcript keeps when (its "Reloaded: …" line).
+    const sessionId = str(at(session, 'sessionId'));
+    const reloaded = sessionId ? lastReload(config, input.projectRoot, sessionId) : null;
+    if (reloaded !== null) plugins = now - reloaded < LAG_AFTER_MS ? [] : plugins.filter((p) => p.at > reloaded);
+  }
+  if (!claude && plugins.length === 0) return null;
+  return { claude, plugins: plugins.map(({ name, version }) => ({ name, version })) };
+}
+
+/** Enabled plugins and when each was last updated (ms) — the user's and this project's. */
+function updatedPlugins(config: string, projectRoot: string): Array<{ name: string; version: string; at: number }> {
+  const records = dict(at(readJson(path.join(config, 'plugins', 'installed_plugins.json')), 'plugins')) ?? {};
+  // The nearest settings that name a plugin decide: the project's local, the project's, the user's.
+  const layers = [
+    path.join(projectRoot, '.claude', 'settings.local.json'),
+    path.join(projectRoot, '.claude', 'settings.json'),
+    path.join(config, 'settings.json'),
+  ].map((f) => dict(at(readJson(f), 'enabledPlugins')) ?? {});
+  const out: Array<{ name: string; version: string; at: number }> = [];
+  for (const [key, entries] of Object.entries(records)) {
+    if (layers.map((l) => l[key]).find((v) => typeof v === 'boolean') !== true) continue;
+    const entry = list(entries).find((e) => at(e, 'scope') === 'user' || at(e, 'projectPath') === projectRoot);
+    const when = Date.parse(str(at(entry, 'lastUpdated')) ?? '');
+    const version = str(at(entry, 'version'));
+    if (Number.isNaN(when) || !version) continue;
+    out.push({ name: key.split('@')[0] ?? key, version, at: when });
+  }
+  return out;
+}
+
+/** When the session last ran /reload-plugins (ms), from its transcript; null — never, or no transcript here. */
+function lastReload(config: string, projectRoot: string, sessionId: string): number | null {
+  const projects = path.join(config, 'projects');
+  let file = path.join(projects, projectDirName(projectRoot), `${sessionId}.jsonl`);
+  if (!fs.existsSync(file)) {
+    // The transcript sits under the directory the session started in, which may be another.
+    const dir = safeReaddir(projects).find((d) => fs.existsSync(path.join(projects, d, `${sessionId}.jsonl`)));
+    if (dir === undefined) return null;
+    file = path.join(projects, dir, `${sessionId}.jsonl`);
+  }
+  let text: string;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return null;
+  }
+  let last: number | null = null;
+  for (const line of text.split('\n')) {
+    if (!line.includes('"local_command"') || !line.includes('Reloaded:')) continue;
+    let entry: unknown;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (at(entry, 'type') !== 'system' || at(entry, 'subtype') !== 'local_command') continue;
+    if (!/<local-command-stdout>Reloaded:/.test(str(at(entry, 'content')) ?? '')) continue;
+    const when = Date.parse(str(at(entry, 'timestamp')) ?? '');
+    if (!Number.isNaN(when) && (last === null || when > last)) last = when;
+  }
+  return last;
+}
+
+/** `2.1.304 (Claude Code)` → `2.1.304`. */
+function versionOf(text: string | null): string | null {
+  return text?.match(/\d+\.\d+\.\d+/)?.[0] ?? null;
+}
+
+/** Whether version `a` is newer than `b`, part by part. */
+function newer(a: string, b: string): boolean {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d > 0;
+  }
+  return false;
+}
+
+function readJson(file: string): unknown {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function safeReaddir(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}