@vodmal/vdx-cli 0.35.0 → 0.37.0

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/doctor.ts

@@ -4,9 +4,24 @@ import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 import { effectiveAuthor, isGitRepo, rankAuthors, remoteParts, scanPool } from './author.ts';
-import { authorPoolDirs, loadEnvironment, resolveEnvironmentPath, shellQuote, type Environment } from './ai.ts';
+import {
+  authorPoolDirs,
+  loadEnvironment,
+  resolveEnvironmentPath,
+  resolveProjectRoot,
+  shellQuote,
+  type Environment,
+} from './ai.ts';
 import { checkRepoHooks } from './clone-checks.ts';
 import { githubToken, machineIo, type HostingIo } from './hosting.ts';
+import {
+  describeMemory,
+  fixProjectMemory,
+  memoryNeedsFix,
+  memoryState,
+  type MemoryCtx,
+  type MemoryState,
+} from './memory.ts';
 import { at, dict, errorMessage, str } from './narrow.ts';
 import {
   checkPersonalHooks,
@@ -24,6 +39,8 @@ export interface CheckResult {
   level?: number;
   message: string;
   remedy?: string;
+  /** For the agent's own session (`--check`): what the fix does not change for it. */
+  sessionNote?: string;
 }
 
 /**
@@ -473,6 +490,52 @@ export function checkGithubToken(
   };
 }
 
+/** The profile, or none: a broken one is `vdx ai`'s report, not a reason for doctor to stop. */
+function profile(): Environment {
+  const file = resolveEnvironmentPath();
+  try {
+    return file ? loadEnvironment(file) : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Claude Code is the project's agent: the profile names it, or names no agent at all. */
+function claudeIsTheAgent(environment: Environment): boolean {
+  return path.basename(environment.agent?.command ?? 'claude') === 'claude';
+}
+
+function memoryCtx(): MemoryCtx {
+  return { env: process.env, home: os.homedir() };
+}
+
+/**
+ * Where Claude Code keeps the project's memory (claude-memory-in-project): inside the
+ * project, `.claude/memory/`, so a moved folder takes it along — and the path set there
+ * is the trace a move leaves.
+ */
+export function checkClaudeMemory(
+  ctx: DoctorCtx,
+  environment: Environment = profile(),
+  mctx: MemoryCtx = memoryCtx(),
+): CheckResult | null {
+  if (ctx.projectRoot === null || !claudeIsTheAgent(environment)) return null;
+  // Claude Code's slot is the folder the agent starts in — the checkout's top for vdx ai.
+  const root = resolveProjectRoot(ctx.projectRoot) ?? ctx.projectRoot;
+  const state = memoryState(root, mctx);
+  return {
+    id: 'claude-memory',
+    label: 'Claude memory',
+    status: memoryNeedsFix(state) ? 'warning' : 'ok',
+    message: describeMemory(state, mctx),
+    ...(memoryNeedsFix(state) ? { remedy: `vdx doctor --fix ${shellQuote(root)}` } : {}),
+    // A session read the place when it started: after a fix it keeps writing to the old one.
+    ...(state.kind === 'outside' || state.kind === 'moved' || state.kind === 'elsewhere'
+      ? { sessionNote: 'This session keeps the old place until it restarts (vdx ai --restart).' }
+      : {}),
+  };
+}
+
 const CHECKS: Array<(ctx: DoctorCtx) => CheckResult | null> = [
   checkVdxVersion,
   checkVdx,
@@ -487,6 +550,7 @@ const CHECKS: Array<(ctx: DoctorCtx) => CheckResult | null> = [
   (ctx) => checkPersonalHooks(ctx.projectRoot),
   checkGitAuthor,
   (ctx) => checkGithubToken(ctx),
+  (ctx) => checkClaudeMemory(ctx),
 ];
 
 export function resolveDoctorCtx(cwd: string = process.cwd()): DoctorCtx {
@@ -510,13 +574,20 @@ export function runDoctor(ctx: DoctorCtx = resolveDoctorCtx()): DoctorReport {
 export function runDoctorCheck(
   ctx: DoctorCtx = resolveDoctorCtx(),
   deps: PersonalHookDeps = defaultPersonalHookDeps(),
+  environment: Environment = profile(),
+  mctx: MemoryCtx = memoryCtx(),
 ): string {
-  const rows = [checkRepoHooks(ctx.projectRoot), checkPersonalHooks(ctx.projectRoot, deps)].filter(
-    (c): c is CheckResult => c !== null && c.status !== 'ok',
-  );
+  const rows = [
+    checkRepoHooks(ctx.projectRoot),
+    checkPersonalHooks(ctx.projectRoot, deps),
+    checkClaudeMemory(ctx, environment, mctx),
+  ].filter((c): c is CheckResult => c !== null && c.status !== 'ok');
   return rows
     .map(
-      (c) => `vdx doctor: ${c.label} — ${c.message}.` + (c.remedy ? ` Fix, on the user's word: \`${c.remedy}\`.` : ''),
+      (c) =>
+        `vdx doctor: ${c.label} — ${c.message}.` +
+        (c.remedy ? ` Fix, on the user's word: \`${c.remedy}\`.` : '') +
+        (c.sessionNote ? ` ${c.sessionNote}` : ''),
     )
     .join('\n');
 }
@@ -530,6 +601,18 @@ export function runDoctorFix(deps: PersonalHookDeps = defaultPersonalHookDeps())
   return fixPersonalHooks(deps);
 }
 
+/** `vdx doctor --fix` for the memory: the profile's personal hosts, this machine's Claude Code. */
+export function fixDoctorMemory(
+  projectRoot: string,
+  state: MemoryState,
+  io: { ask: (prompt: string) => string | null; log: (line: string) => void; today: string },
+): string[] {
+  return fixProjectMemory(projectRoot, state, memoryCtx(), {
+    ...io,
+    personalHosts: profile().git?.personal_hosts ?? [],
+  });
+}
+
 const PROJECT_MARKER_FILES = [
   'package.json',
   'composer.json',

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import * as os from 'node:os';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { loadRubric } from './rubric.ts';
@@ -16,6 +17,8 @@ import {
   reportDoctorAnsi,
 } from './report.ts';
 import {
+  checkClaudeMemory,
+  fixDoctorMemory,
   runDoctor,
   runDoctorCheck,
   runDoctorFix,
@@ -23,6 +26,7 @@ import {
   looksLikeProject,
   readCliVersion,
 } from './doctor.ts';
+import { memoryState } from './memory.ts';
 import { planInit, writeInit, renderPlanSummary } from './init.ts';
 import {
   planPublish,
@@ -35,7 +39,17 @@ 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,
+  resolveProjectRoot,
+} from './ai.ts';
 import { isConversationId } from './conversations.ts';
 
 const DEFAULT_RUBRIC = resolveDefaultRubric();
@@ -90,11 +104,27 @@ 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
@@ -116,6 +146,11 @@ ones marked — Enter takes the newest; without a terminal it takes this
 machine's. A new conversation (--new, or none to continue) while an agent of
 the project runs on another machine starts only after a yes.
 
+Claude Code's memory of the project (Claude Code only): when it is not inside the
+project, .claude/memory/, or the folder was moved, a start in a terminal asks to
+put it there — Enter does, as vdx doctor --fix; with an agent of the project
+running, or no terminal, it only names that command.
+
 Exit codes: 0 the agent runs per the profile; 2 profile or usage error;
 3 the running agent lacks profile flags, or is not focused under --focused,
 and was left as is — no terminal, or q (rerun with --restart); 4 the start
@@ -166,8 +201,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,
@@ -204,25 +240,35 @@ Claude Code plugin) and, inside a project (default: cwd), its commit author and
 its git hooks: are the hooks the repository declares on in this clone, and do
 the personal hooks of your profile (git.hooks) run on this machine; with origin on
 GitHub, the token vdx asks GitHub with ($GH_TOKEN, $GITHUB_TOKEN or gh) and
-whether it works — without one GitHub answers 60 requests an hour. Reads only.
-Exit 2 when something is missing.
+whether it works — without one GitHub answers 60 requests an hour; and where
+Claude Code keeps the project's memory: inside it, .claude/memory/, a moved folder
+takes it along. Reads only, unless --fix. Exit 2 when something is missing.
 
   --check  for the agent's own session (the vdx plugin's SessionStart hook): one
-           line per hook that is declared but does not run here; nothing when in order
+           line per hook that is declared but does not run here, and one when the
+           memory is not inside; nothing when in order
   --fix    write the profile's personal hooks into ~/.gitconfig where they are
-           missing or differ; repository hooks are switched on by the project's
-           install step, which the report names
+           missing or differ (repository hooks are switched on by the project's
+           install step, which the report names); and put the memory inside:
+           notes from ~/.claude/projects/<path>/memory into .claude/memory/, none
+           overwritten, the old place renamed, autoMemoryDirectory written —
+           into .claude/settings.json in a personal project (no origin, or origin
+           on a host of git.personal_hosts), else into .claude/settings.local.json,
+           with the memory kept out of git (.git/info/exclude) unless you say
+           yes. After a folder is moved: the path follows it, and the project's
+           conversations move to the new path
 `,
     bools: ['json', 'check', 'fix'],
     values: ['format'],
     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(
@@ -412,6 +458,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);
@@ -568,6 +626,22 @@ function cmdDoctor(opts: ParsedArgs): void {
       process.stderr.write(`vdx doctor --fix: ${errorMessage(e)}\n`);
       process.exit(2);
     }
+    const root = ctx.projectRoot ? resolveProjectRoot(ctx.projectRoot) : null;
+    const memory = root ? checkClaudeMemory({ projectRoot: root }) : null;
+    if (root && memory?.remedy) {
+      try {
+        const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+        const done = fixDoctorMemory(root, memoryState(root, { env: process.env, home: os.homedir() }), {
+          ask: (prompt) => (interactive ? askLine(prompt) : null),
+          log: (line) => process.stderr.write(line + '\n'),
+          today: new Date().toLocaleDateString('sv-SE'),
+        });
+        process.stderr.write(done.map((d) => `✓ ${d}`).join('\n') + (done.length ? '\n' : ''));
+      } catch (e) {
+        process.stderr.write(`vdx doctor --fix: Claude memory — ${errorMessage(e)}\n`);
+        process.exit(2);
+      }
+    }
   }
   const report = runDoctor(ctx);
 
@@ -602,6 +676,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`);
@@ -619,6 +714,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.7.0';
 
 const VERB_ALIASES: Record<Verb, string[]> = {
   up: ['docker:up', 'docker-up', 'docker:up:detached', 'start', 'dev', 'serve'],