@vodmal/vdx-cli 0.38.0 → 0.39.0

package/README.md

@@ -56,7 +56,8 @@ vdx doctor --check [project-path]   # one line per hook declared but not running
                                     # not inside — the plugin's SessionStart hook tells the agent
 vdx doctor --fix [project-path]     # write the profile's personal hooks (git.hooks) into ~/.gitconfig, and put
                                     # the project's Claude Code memory inside it: .claude/memory/ (after a
-                                    # folder move, its path and conversations follow)
+                                    # folder move, its path and conversations follow; notes a session that
+                                    # started before the move wrote at the old place come in)
 
 # Start your agent in a project per your profile (~/.vdx-environment.yaml or $VDX_ENVIRONMENT)
 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
@@ -116,7 +117,8 @@ The session's `{project}` is `[_.vdx] name` (or the older `[vdx]`) from the proj
 first file in the profile's `session.project_names` that has one, else the repo
 name. `vdx ai@<host>` runs the same command on `<host>` over ssh — that machine's vdx,
 profile and tmux, the path taken under its home directory; `--detach` only
-starts it. The machine's own label (`$VDX_HOST`) runs here. Where git knows no
+starts it, and not in a folder Claude Code does not trust yet: nobody would answer
+its trust window (exit 4; start once without `--detach`). The machine's own label (`$VDX_HOST`) runs here. Where git knows no
 commit author, `vdx ai` proposes one (Enter writes it into `.git/config`).
 For Claude Code `vdx ai` picks the conversation: each one is marked with the
 machine it was last started on (`vdx ai --check`, run by the plugin's hook, writes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodmal/vdx-cli",
-  "version": "0.38.0",
+  "version": "0.39.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.7.0"
+  version: "1.8.0"
   description: "Personal maturity rubric for multi-stack projects (vodmal)"
   owner: vodmal
   homepage: "https://github.com/vodmal/vdx-rubric"

package/src/ai.ts

@@ -10,6 +10,7 @@ import { loadManifestAt } from './manifest.ts';
 import { type Author, effectiveAuthor, isGitRepo, rankAuthors, scanPool, writeAuthor } from './author.ts';
 import type { Predicate } from './rubric.ts';
 import {
+  claudeTrusts,
   type Conversation,
   describeConversation,
   describeAge,
@@ -1767,9 +1768,10 @@ export function runAiCheck(pathArg: string, deps: AiDeps, selfPid: number = proc
     `Hand the user the fix — ${reload}` +
       (deps.env['TMUX']
         ? `\`${vdxAi} --restart ${root}\`: it stops this session and starts it again${again}` +
-          // A focused session and the mail session restart into a new conversation.
+          // A focused session and the mail session restart into a new conversation, and what lives
+          // only in this one ends with it (ai-dev-plugins, restart-hint-wrap-first).
           (focused || intercom
-            ? ', in a new conversation'
+            ? ", in a new conversation — before handing it over, run the project's wrap check (`/vdm:wrap` where vdm is installed): what lives only in this chat ends with it"
             : plan.resumeArgs.length
               ? `, resuming the conversation (${plan.resumeArgs.join(' ')})`
               : '') +
@@ -2102,6 +2104,14 @@ export function runAi(opts: AiOptions, deps: AiDeps): number {
     if (live) plan = { ...plan, resumeArgs: resumeId(live) };
   }
 
+  // Nobody sits at a detached start, and Claude Code holds one in a folder it does not trust on
+  // its trust window, unseen (intercom-session-mode Sidetrack #4). The answer is the person's.
+  if (opts.detach && isClaude(plan.command) && claudeTrusts(projectRoot, deps.env, deps.home) === false) {
+    log(`✗ Claude Code has not trusted ${projectRoot} yet: a detached agent would wait on its trust window, unseen`);
+    log(`  start it once at a terminal and answer the window: ${vdxAiHere} ${shellQuote(projectRoot)}`);
+    return EXIT_LAUNCH_FAILED;
+  }
+
   if (current) {
     const line = agentLine(plan, [...plan.args, ...plan.resumeArgs]);
     log(`↻ ${current.pane.session} ${current.pane.paneId}: restarting — ${line}`);

package/src/conversations.ts

@@ -69,6 +69,41 @@ export function claudeConfigDir(env: NodeJS.ProcessEnv, home: string): string {
   return dir ? path.resolve(dir.replace(/^~(?=$|\/)/, home)) : path.join(home, '.claude');
 }
 
+/**
+ * Whether Claude Code trusts a folder (2.1.308, claude-memory-in-project DL #13): its global
+ * config, `.claude.json` in `CLAUDE_CONFIG_DIR` or the home directory, marks
+ * `projects[<folder>].hasTrustDialogAccepted` for the folder or one above it — inside a git
+ * checkout only up to the checkout's top. A start in a folder it does not trust stops on the
+ * trust window until somebody answers. Null: the config cannot be read, nobody knows.
+ */
+export function claudeTrusts(folder: string, env: NodeJS.ProcessEnv, home: string): boolean | null {
+  const dir = env['CLAUDE_CONFIG_DIR']?.trim();
+  let projects: Record<string, unknown> | undefined;
+  try {
+    const file = path.join(dir ? path.resolve(dir.replace(/^~(?=$|\/)/, home)) : home, '.claude.json');
+    projects = dict(at(JSON.parse(fs.readFileSync(file, 'utf8')), 'projects'));
+  } catch {
+    return null;
+  }
+  let d = path.resolve(folder);
+  try {
+    d = fs.realpathSync(d);
+  } catch {
+    // A folder that is not there is trusted by nothing but its own record.
+  }
+  let top: string | null = null;
+  for (let p = d; top === null; p = path.dirname(p)) {
+    if (fs.existsSync(path.join(p, '.git'))) top = p;
+    if (path.dirname(p) === p) break;
+  }
+  for (;;) {
+    if (at(projects?.[d.normalize('NFC')], 'hasTrustDialogAccepted') === true) return true;
+    const up = path.dirname(d);
+    if (d === top || up === d) return false;
+    d = up;
+  }
+}
+
 export function projectDirName(projectRoot: string): string {
   return projectRoot.replace(/[^A-Za-z0-9]/g, '-');
 }

package/src/index.ts

@@ -129,7 +129,10 @@ the project's files). Hand a person \`vdx ai\`, not \`<agent> --<flag>\`.
                 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
+  --detach      start without attaching; print the command that attaches. In a
+                folder Claude Code does not trust yet, nothing starts (exit 4):
+                its trust window would wait with nobody at it — start once
+                without --detach and answer it
   --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,
                 whether this session carries the profile's flags, and whether it
@@ -258,7 +261,11 @@ takes it along. Reads only, unless --fix. Exit 2 when something is missing.
            its commits go — see --staged), 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
+           conversations move to the new path; a folder Claude Code has not
+           trusted yet is named. Notes a session that started before the move
+           wrote at the old place come in, with their MEMORY.md lines; a path
+           another clone left in the shared settings.json goes, for this clone,
+           into its .claude/settings.local.json
   --staged the profile's pre-commit hook: refuses a commit that stages
            .claude/memory/ unless only you read every place the commit reaches —
            origin on a host of git.personal_hosts or a private GitHub repo with

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.7.0';
+export const DEFAULT_BASELINE = 'github.com/VoDmAl/vdx-rubric-vodmal@v1.8.0';
 
 const VERB_ALIASES: Record<Verb, string[]> = {
   up: ['docker:up', 'docker-up', 'docker:up:detached', 'start', 'dev', 'serve'],

package/src/memory.ts

@@ -2,7 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { remoteParts } from './author.ts';
-import { claudeConfigDir, projectDirName } from './conversations.ts';
+import { claudeConfigDir, claudeTrusts, projectDirName } from './conversations.ts';
 import { githubToken, machineIo, type HostingIo } from './hosting.ts';
 import { at, dict, errorMessage, list, str } from './narrow.ts';
 
@@ -18,8 +18,11 @@ import { at, dict, errorMessage, list, str } from './narrow.ts';
 export type MemoryState =
   /** In `.claude/memory/`, nothing left in the old place. */
   | { kind: 'inside' }
-  /** In `.claude/memory/`, and notes still lie in the old place — a move made by hand. */
-  | { kind: 'leftovers'; old: string; notes: number; differ: number; onlyOld: number }
+  /**
+   * In `.claude/memory/`, and notes still lie in the old place — a move made by hand. `afterMove`:
+   * vdx set the old place aside before, so a session that started before the move wrote them.
+   */
+  | { kind: 'leftovers'; old: string; notes: number; differ: number; onlyOld: number; afterMove: boolean }
   /** Not set: memory goes to the old place. */
   | { kind: 'outside'; old: string; notes: number }
   /**
@@ -109,6 +112,11 @@ function entries(dir: string): string[] {
   }
 }
 
+/** vdx set this place aside once already (`asideName`): what lies there now came after (Sidetrack #5). */
+function setAsideBefore(dir: string): boolean {
+  return entries(path.dirname(dir)).some((n) => n.startsWith(`${path.basename(dir)}.moved-`));
+}
+
 function sameFile(a: string, b: string): boolean {
   try {
     return fs.readFileSync(a).equals(fs.readFileSync(b));
@@ -130,7 +138,14 @@ export function memoryState(projectRoot: string, ctx: MemoryCtx): MemoryState {
       (n) => fs.existsSync(path.join(target, n)) && !sameFile(path.join(old, n), path.join(target, n)),
     );
     const onlyOld = notes.filter((n) => !fs.existsSync(path.join(target, n)));
-    return { kind: 'leftovers', old, notes: notes.length, differ: differ.length, onlyOld: onlyOld.length };
+    return {
+      kind: 'leftovers',
+      old,
+      notes: notes.length,
+      differ: differ.length,
+      onlyOld: onlyOld.length,
+      afterMove: setAsideBefore(old),
+    };
   }
   if (path.basename(setting.dir) === 'memory' && path.basename(path.dirname(setting.dir)) === '.claude') {
     const from = path.dirname(path.dirname(setting.dir));
@@ -253,6 +268,8 @@ export function describeMemory(state: MemoryState, ctx: MemoryCtx): string {
     case 'inside':
       return 'in .claude/memory/';
     case 'leftovers': {
+      if (state.afterMove)
+        return `in .claude/memory/, and ${state.notes} note(s) written in the old place after the move, ${tilde(state.old, ctx.home)} — by a session that started before it; the fix brings them in`;
       const parts = [state.differ ? `${state.differ} differ` : '', state.onlyOld ? `${state.onlyOld} only there` : '']
         .filter(Boolean)
         .join(', ');
@@ -288,10 +305,10 @@ function asideName(dir: string, today: string): string {
   return name;
 }
 
-/** Copies what `to` lacks; a name `to` already has stays as it is there. Returns the names kept. */
-function copyMissing(from: string, to: string): { copied: number; kept: string[] } {
+/** Copies what `to` lacks; a name `to` already has stays as it is there. Returns the names copied and kept. */
+function copyMissing(from: string, to: string): { copied: string[]; kept: string[] } {
   fs.mkdirSync(to, { recursive: true });
-  let copied = 0;
+  const copied: string[] = [];
   const kept: string[] = [];
   for (const name of entries(from)) {
     const src = path.join(from, name);
@@ -301,11 +318,42 @@ function copyMissing(from: string, to: string): { copied: number; kept: string[]
       continue;
     }
     fs.cpSync(src, dst, { recursive: true, errorOnExist: true, force: false });
-    copied++;
+    copied.push(name);
   }
   return { copied, kept };
 }
 
+const INDEX = 'MEMORY.md';
+
+/**
+ * Notes a session wrote at the old place after the move, brought into `to`: the agent finds a
+ * note by its line in MEMORY.md, so the lines of the old index that point at the notes
+ * brought in join `to`'s — those alone. A line about a note `to` already has is the
+ * project's agent's to judge (DL #8). Returns what was done, one line each, and the names kept.
+ */
+function bringIn(from: string, to: string, what: string, aside: string): { done: string[]; differ: string[] } {
+  const { copied, kept } = copyMissing(from, to);
+  const done = [`${copied.length} note(s) ${what} → .claude/memory/`];
+  const notes = copied.filter((n) => n !== INDEX);
+  const src = path.join(from, INDEX);
+  const dst = path.join(to, INDEX);
+  if (notes.length && !copied.includes(INDEX) && fs.existsSync(src)) {
+    const have = fs.existsSync(dst) ? fs.readFileSync(dst, 'utf8') : '';
+    const lines = fs
+      .readFileSync(src, 'utf8')
+      .split('\n')
+      .filter((l) => notes.some((n) => l.includes(`](${n})`) && !have.includes(`(${n})`)));
+    if (lines.length) {
+      fs.writeFileSync(dst, have + (have && !have.endsWith('\n') ? '\n' : '') + lines.join('\n') + '\n');
+      done.push(`${lines.length} line(s) of its MEMORY.md → .claude/memory/MEMORY.md, for the notes brought in`);
+    }
+  }
+  const differ = kept.filter((n) => n !== INDEX);
+  if (differ.length)
+    done.push(`kept .claude/memory/ as it is for ${differ.join(', ')} — the later copy differs, it stays in ${aside}`);
+  return { done, differ };
+}
+
 /** Sets `autoMemoryDirectory` in a settings file, keeping its other keys. */
 function writeSetting(file: string, dir: string): void {
   let doc: Record<string, unknown> = {};
@@ -380,12 +428,22 @@ export function fixMemory(projectRoot: string, state: MemoryState, ctx: MemoryCt
     case 'custom':
       return done;
     case 'leftovers':
+      // Written after vdx's move by a session that started before it: newer than anything inside.
+      if (state.afterMove)
+        done.push(
+          ...bringIn(
+            state.old,
+            target,
+            'written in the old place after the move',
+            tilde(asideName(state.old, opts.today), ctx.home),
+          ).done,
+        );
       setAside(state.old);
       return done;
     case 'outside': {
-      const { copied, kept } = fs.existsSync(state.old) ? copyMissing(state.old, target) : { copied: 0, kept: [] };
+      const { copied, kept } = fs.existsSync(state.old) ? copyMissing(state.old, target) : { copied: [], kept: [] };
       if (!fs.existsSync(target)) fs.mkdirSync(target, { recursive: true });
-      done.push(`${copied} note(s) → .claude/memory/`);
+      done.push(`${copied.length} note(s) → .claude/memory/`);
       if (kept.length) done.push(`kept .claude/memory/ as it is for ${kept.join(', ')} — the old copy differs`);
       const file = path.join(root, '.claude', opts.personal ? 'settings.json' : 'settings.local.json');
       writeSetting(file, target);
@@ -405,18 +463,40 @@ export function fixMemory(projectRoot: string, state: MemoryState, ctx: MemoryCt
     }
     case 'moved':
     case 'elsewhere': {
-      writeSetting(state.setting.file, target);
-      done.push(`autoMemoryDirectory → ${target}/ (${path.relative(root, state.setting.file)})`);
+      // The path is rewritten where it was read — unless that file is the user's, read by every
+      // project, or another clone's path in the repo's shared settings.json: then this clone's
+      // own local settings, read first (Sidetrack #4).
+      const local = path.join(root, '.claude', 'settings.local.json');
+      const inProject = path.dirname(state.setting.file) === path.join(root, '.claude');
+      const shared =
+        state.kind === 'elsewhere' &&
+        state.setting.file !== local &&
+        git(root, ['ls-files', '--error-unmatch', '--', path.relative(root, state.setting.file)]) !== null;
+      const file = inProject && !shared ? state.setting.file : local;
+      writeSetting(file, target);
+      done.push(`autoMemoryDirectory → ${target}/ (${path.relative(root, file)})`);
+      if (shared) done.push(`${path.relative(root, state.setting.file)} keeps the other clone's path — it is shared`);
       if (state.kind === 'moved' && state.stray) {
-        const { copied, kept } = copyMissing(state.stray, target);
+        const brought = bringIn(
+          state.stray,
+          target,
+          'written at the old path after the move',
+          tilde(state.stray, ctx.home),
+        );
         done.push(
-          `${copied} note(s) written at the old path after the move → .claude/memory/${kept.length ? `; kept .claude/memory/ as it is for ${kept.join(', ')}` : ''} — ${tilde(state.from, ctx.home)} holds only them, remove it`,
+          ...brought.done,
+          `${tilde(state.from, ctx.home)} holds only them — remove it${brought.differ.length ? ` once ${brought.differ.join(', ')} is settled` : ''}`,
         );
       }
       if (state.kind === 'moved' && state.conversations) {
         const here = path.join(claudeConfigDir(ctx.env, ctx.home), 'projects', projectDirName(root));
         done.push(moveConversations(state.conversations, here, opts.today));
       }
+      // Claude Code trusts a folder by its path: the moved one is new to it (Sidetrack #2).
+      if (state.kind === 'moved' && claudeTrusts(root, ctx.env, ctx.home) === false)
+        done.push(
+          'Claude Code has not trusted this folder yet: its first start here stops on the trust window — start vdx ai here once and answer it; a detached start (the mail session) is refused until then',
+        );
       return done;
     }
   }
@@ -451,7 +531,10 @@ export function fixProjectMemory(
     underGit = /^y(es)?$/i.test(deps.ask('  Keep .claude/memory/ under git? [y/N] ')?.trim() ?? '');
   }
   const done = fixMemory(projectRoot, state, ctx, { personal, underGit, today: deps.today });
-  if (done.length && (state.kind === 'outside' || state.kind === 'moved')) {
+  if (
+    done.length &&
+    (state.kind === 'outside' || state.kind === 'moved' || (state.kind === 'leftovers' && state.afterMove))
+  ) {
     done.push('sessions of this project running now keep the old place until they restart');
   }
   return done;