@vodmal/vdx-cli 0.24.0 → 0.26.0

package/src/index.ts

@@ -2,14 +2,10 @@
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { loadRubric } from './rubric.ts';
-import { loadManifest, loadOverrides } from './manifest.ts';
+import { loadManifest, loadManifestAt, loadOverrides } from './manifest.ts';
 import { autoDetectStack, type Ctx } from './facts.ts';
-import {
-  LIFECYCLE_VERBS,
-  type LifecycleVerb,
-  resolveLifecycleVerb,
-  renderResolveError,
-} from './run.ts';
+import { at, errorMessage } from './narrow.ts';
+import { LIFECYCLE_VERBS, type LifecycleVerb, resolveLifecycleVerb, renderResolveError } from './run.ts';
 import { audit } from './audit.ts';
 import {
   reportMarkdown,
@@ -19,7 +15,14 @@ import {
   reportDoctorJson,
   reportDoctorAnsi,
 } from './report.ts';
-import { runDoctor, runDoctorCheck, runDoctorFix, resolveDoctorCtx, looksLikeProject, readCliVersion } from './doctor.ts';
+import {
+  runDoctor,
+  runDoctorCheck,
+  runDoctorFix,
+  resolveDoctorCtx,
+  looksLikeProject,
+  readCliVersion,
+} from './doctor.ts';
 import { planInit, writeInit, renderPlanSummary } from './init.ts';
 import {
   planPublish,
@@ -66,6 +69,7 @@ interface CommandSpec {
 }
 
 const AI_HELP = `Starts your agent in the project, or attaches to the one already running there.
+Several running there: a list to pick from — Enter takes the newest.
 Which agent, its flags and whether it runs in tmux come from your profile:
 $VDX_ENVIRONMENT, else ~/.vdx-environment.yaml, else a plain claude/codex.
 
@@ -75,15 +79,20 @@ the project's files). Hand a person \`vdx ai\`, not \`<agent> --<flag>\`.
 
   project_path  the project (default: cwd); its git toplevel is used
   @host         the same command on <host> over ssh: its vdx, profile and tmux
-  --new         a new conversation instead of continuing the last one
-  --focused     a session nothing wakes: the agent, its hooks and MCP servers get
-                VDX_FOCUSED=1 — for the plugins that wake sessions to leave it
-                alone — and the profile's rules marked \`wakes: true\` (a channel
-                flag) are left out. A running agent keeps its mode; --restart
-                applies this one
+  --new         a new conversation instead of continuing the last one; an agent
+                already running here keeps running, the new one starts next to
+                it (a new tmux window)
+  --focused     a new conversation, as --new, in a session nothing wakes: the
+                agent, its hooks and MCP servers get VDX_FOCUSED=1 — for the
+                plugins that wake sessions to leave it alone — and the profile's
+                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
   --conversation <id>
-                continue this Claude Code conversation
-  --restart     restart the running agent in its pane — applies a changed profile.
+                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.
                 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
@@ -251,7 +260,9 @@ function checkArgs(name: string, opts: ParsedArgs): ParsedArgs {
     process.exit(2);
   };
   const unknown = [
-    ...Object.keys(flags).filter((f) => !bools.includes(f) && !values.includes(f)).map((f) => `--${f}`),
+    ...Object.keys(flags)
+      .filter((f) => !bools.includes(f) && !values.includes(f))
+      .map((f) => `--${f}`),
     ...positionals.filter((p) => p.startsWith('-')),
   ];
   if (unknown.length > 0) fail(`unknown option ${unknown.join(', ')}`);
@@ -275,14 +286,20 @@ function cmdAudit(opts: ParsedArgs): void {
     );
   }
 
-  const manifest = loadManifest(projectRoot);
+  const found = loadManifestAt(projectRoot);
+  const manifest = found?.manifest ?? null;
+  if (found?.place === 'vdx') {
+    process.stderr.write(
+      'note: the manifest is in [vdx] of mise.toml, and mise 2026.10 warns about it on every run; ' +
+        'its place is [_.vdx], once every machine of the project runs vdx 0.26 or newer\n',
+    );
+  }
   const overrides = loadOverrides(projectRoot);
 
   const rubricPath = (opts.flags.rubric as string) || DEFAULT_RUBRIC;
   const rubric = loadRubric(rubricPath);
 
-  const stack =
-    (opts.flags.stack as string) || manifest?.stack || autoDetectStack(projectRoot);
+  const stack = (opts.flags.stack as string) || manifest?.stack || autoDetectStack(projectRoot);
 
   const ctx: Ctx = {
     projectRoot,
@@ -293,8 +310,7 @@ function cmdAudit(opts: ParsedArgs): void {
   const baselineRef = manifest?.baseline ?? `file://${rubricPath}`;
   const result = audit(rubric, ctx, overrides, baselineRef, manifest);
 
-  const formatFlag =
-    typeof opts.flags.format === 'string' ? opts.flags.format : undefined;
+  const formatFlag = typeof opts.flags.format === 'string' ? opts.flags.format : undefined;
   const wantJson = opts.flags.json === true || formatFlag === 'json';
   const wantMarkdown = formatFlag === 'markdown' || formatFlag === 'md';
   const wantAnsi = formatFlag === 'ansi';
@@ -338,8 +354,8 @@ function cmdInit(opts: ParsedArgs): void {
   try {
     writeInit(plan, { force: Boolean(opts.flags.force) });
     process.stderr.write(`\n✓ wrote ${plan.miseTomlPath}\n`);
-  } catch (e: any) {
-    process.stderr.write(`\nerror: ${e?.message ?? String(e)}\n`);
+  } catch (e) {
+    process.stderr.write(`\nerror: ${errorMessage(e)}\n`);
     process.exit(2);
   }
 }
@@ -347,9 +363,7 @@ function cmdInit(opts: ParsedArgs): void {
 function cmdPublish(opts: ParsedArgs): void {
   const bumpArg = opts.positionals[0];
   if (!bumpArg || !['patch', 'minor', 'major'].includes(bumpArg)) {
-    process.stderr.write(
-      'Usage: vdx publish <patch|minor|major> [--dry-run] [--force] [--no-push]\n',
-    );
+    process.stderr.write('Usage: vdx publish <patch|minor|major> [--dry-run] [--force] [--no-push]\n');
     process.exit(1);
   }
   const bump = bumpArg as BumpKind;
@@ -374,8 +388,8 @@ function cmdPublish(opts: ParsedArgs): void {
   const replan = () => {
     try {
       return planPublish(planOpts, auditResult, ctx);
-    } catch (e: any) {
-      process.stderr.write(`error: ${e?.message ?? String(e)}\n`);
+    } catch (e) {
+      process.stderr.write(`error: ${errorMessage(e)}\n`);
       process.exit(2);
     }
   };
@@ -412,8 +426,8 @@ function cmdPublish(opts: ParsedArgs): void {
 
   try {
     executePublish(plan, deps);
-  } catch (e: any) {
-    process.stderr.write(`\nerror: ${e?.message ?? String(e)}\n`);
+  } catch (e) {
+    process.stderr.write(`\nerror: ${errorMessage(e)}\n`);
     process.exit(3);
   }
 }
@@ -428,15 +442,15 @@ function cmdRun(verb: LifecycleVerb): void {
 
   try {
     execFileSync('mise', ['run', verb], { cwd: projectRoot, stdio: 'inherit' });
-  } catch (e: any) {
-    if (e?.code === 'ENOENT') {
+  } catch (e) {
+    if (at(e, 'code') === 'ENOENT') {
       process.stderr.write(
-        `vdx: \`mise\` binary not found on PATH\n` +
-          `hint: install mise — https://mise.jdx.dev/getting-started.html\n`,
+        `vdx: \`mise\` binary not found on PATH\n` + `hint: install mise — https://mise.jdx.dev/getting-started.html\n`,
       );
       process.exit(127);
     }
-    process.exit(typeof e?.status === 'number' ? e.status : 1);
+    const status = at(e, 'status');
+    process.exit(typeof status === 'number' ? status : 1);
   }
 }
 
@@ -454,16 +468,17 @@ function cmdDoctor(opts: ParsedArgs): void {
   if (opts.flags.fix === true) {
     try {
       const done = runDoctorFix();
-      process.stderr.write(done.length > 0 ? done.map((d) => `✓ ${d}`).join('\n') + '\n' : 'nothing to fix in ~/.gitconfig\n');
-    } catch (e: any) {
-      process.stderr.write(`vdx doctor --fix: ${e?.message ?? String(e)}\n`);
+      process.stderr.write(
+        done.length > 0 ? done.map((d) => `✓ ${d}`).join('\n') + '\n' : 'nothing to fix in ~/.gitconfig\n',
+      );
+    } catch (e) {
+      process.stderr.write(`vdx doctor --fix: ${errorMessage(e)}\n`);
       process.exit(2);
     }
   }
   const report = runDoctor(ctx);
 
-  const formatFlag =
-    typeof opts.flags.format === 'string' ? opts.flags.format : undefined;
+  const formatFlag = typeof opts.flags.format === 'string' ? opts.flags.format : undefined;
   const wantJson = opts.flags.json === true || formatFlag === 'json';
   const wantMarkdown = formatFlag === 'markdown' || formatFlag === 'md';
   const wantAnsi = formatFlag === 'ansi';

package/src/init.ts

@@ -1,32 +1,17 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import {
-  Ctx,
-  readJson,
-  listAllTasks,
-  autoDetectStack,
-  findSubPackages,
-  type SubPackage,
-} from './facts.ts';
+import { Ctx, readJson, listAllTasks, autoDetectStack, findSubPackages, type SubPackage } from './facts.ts';
+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.3.0';
+export const DEFAULT_BASELINE = 'github.com/VoDmAl/vdx-rubric-vodmal@v1.4.2';
 
 const VERB_ALIASES: Record<Verb, string[]> = {
   up: ['docker:up', 'docker-up', 'docker:up:detached', 'start', 'dev', 'serve'],
   down: ['docker:down', 'docker-down', 'stop'],
-  build: [
-    'docker:build',
-    'build:prod',
-    'build-prod',
-    'build:dev',
-    'build-dev',
-    'build:assets',
-    'compile',
-    'dist',
-  ],
+  build: ['docker:build', 'build:prod', 'build-prod', 'build:dev', 'build-dev', 'build:assets', 'compile', 'dist'],
   test: [
     'phpunit',
     'pest',
@@ -143,12 +128,7 @@ function renderRunCommand(task: string, stack: string, projectRoot: string): str
   return task;
 }
 
-function renderRunCommandInSubpackage(
-  task: string,
-  subStack: string,
-  subAbs: string,
-  subRel: string,
-): string {
+function renderRunCommandInSubpackage(task: string, subStack: string, subAbs: string, subRel: string): string {
   return `cd ${subRel} && ${renderRunCommand(task, subStack, subAbs)}`;
 }
 
@@ -246,14 +226,10 @@ export function mapVerb(verb: Verb, tasks: Set<string>): string | null {
 
 function collectTools(ctx: Ctx): Record<string, string> {
   const tools: Record<string, string> = {};
-  const composer = readJson(ctx, 'composer.json');
-  if (composer?.require?.php && typeof composer.require.php === 'string') {
-    tools.php = stripVersionConstraint(composer.require.php);
-  }
-  const pkg = readJson(ctx, 'package.json');
-  if (pkg?.engines?.node && typeof pkg.engines.node === 'string') {
-    tools.node = stripVersionConstraint(pkg.engines.node);
-  }
+  const php = at(readJson(ctx, 'composer.json'), 'require', 'php');
+  if (typeof php === 'string' && php) tools.php = stripVersionConstraint(php);
+  const node = at(readJson(ctx, 'package.json'), 'engines', 'node');
+  if (typeof node === 'string' && node) tools.node = stripVersionConstraint(node);
   return tools;
 }
 
@@ -285,16 +261,12 @@ export function renderMiseToml(
   primarySubpackage: string | null = null,
 ): string {
   const out: string[] = [];
-  out.push('# Generated by vdx init. The [vdx] block is metadata for vdx audit.');
+  out.push('# Generated by vdx init. The [_.vdx] block is metadata for vdx audit; mise leaves [_] alone.');
   out.push('# Lifecycle verbs follow the vdx contract: up/down/build/test/check/fix.');
   out.push('');
 
   if (stack === 'unknown' || stack === 'monorepo') {
-    out.push(
-      '# TODO(vdx): stack auto-detection вернул "' +
-        stack +
-        '". Замени на php/node/go/python/meta',
-    );
+    out.push('# TODO(vdx): stack auto-detection вернул "' + stack + '". Замени на php/node/go/python/meta');
     out.push('#   и заполни [tasks.*] блоки руками, либо перегенери: vdx init --stack <id>.');
     out.push('');
   }
@@ -319,7 +291,7 @@ export function renderMiseToml(
     out.push('');
   }
 
-  out.push('[vdx]');
+  out.push('[_.vdx]');
   out.push('schema_version = "0.2"');
   out.push(`baseline = ${quoteToml(baseline)}`);
   out.push(`stack = ${quoteToml(stack)}`);
@@ -336,10 +308,7 @@ export function renderMiseToml(
   return out.join('\n');
 }
 
-export function planInit(
-  projectRoot: string,
-  opts: { baseline?: string; stack?: string } = {},
-): InitPlan {
+export function planInit(projectRoot: string, opts: { baseline?: string; stack?: string } = {}): InitPlan {
   const detectedStack = autoDetectStack(projectRoot);
   const stackOverridden = opts.stack !== undefined && opts.stack !== detectedStack;
   const stack = opts.stack ?? detectedStack;
@@ -365,7 +334,7 @@ export function planInit(
       const list = subs.map((s) => `${s.relPath}(${s.stack})`).join(', ');
       warnings.push(
         `stack="meta", найдено несколько subpackages: ${list}. ` +
-          'primary_subpackage не выбран; укажи его руками в [vdx] блоке.',
+          'primary_subpackage не выбран; укажи его руками в блоке [_.vdx].',
       );
     }
   } else if (!stackOverridden && (detectedStack === 'unknown' || detectedStack === 'monorepo')) {
@@ -436,9 +405,7 @@ export function planInit(
 
 export function writeInit(plan: InitPlan, opts: { force: boolean }): void {
   if (fs.existsSync(plan.miseTomlPath) && !opts.force) {
-    throw new Error(
-      `mise.toml уже существует: ${plan.miseTomlPath}. Используй --force для перезаписи.`,
-    );
+    throw new Error(`mise.toml уже существует: ${plan.miseTomlPath}. Используй --force для перезаписи.`);
   }
   fs.writeFileSync(plan.miseTomlPath, plan.miseTomlContent, 'utf8');
 }
@@ -451,7 +418,9 @@ export function renderPlanSummary(plan: InitPlan, opts: { verbose?: boolean } =
 
   if (!verbose) {
     const lines: string[] = [];
-    lines.push(`vdx init: stack=${plan.stack}${plan.stackOverridden ? ' (via --stack)' : ''}, ${mapped}/${total} verbs mapped`);
+    lines.push(
+      `vdx init: stack=${plan.stack}${plan.stackOverridden ? ' (via --stack)' : ''}, ${mapped}/${total} verbs mapped`,
+    );
     if (plan.primarySubpackage) lines.push(`  primary subpackage: ${plan.primarySubpackage}`);
     if (unmatched.length > 0) {
       lines.push(`  not mapped: ${unmatched.join(', ')} (add [tasks.X] in mise.toml manually)`);
@@ -462,12 +431,8 @@ export function renderPlanSummary(plan: InitPlan, opts: { verbose?: boolean } =
   const lines: string[] = [];
   lines.push(`# vdx init plan`);
   lines.push('');
-  lines.push(
-    `- **Project**: ${plan.projectRoot}`,
-  );
-  lines.push(
-    `- **Stack**: ${plan.stack}${plan.stackOverridden ? ' (via --stack)' : ''}`,
-  );
+  lines.push(`- **Project**: ${plan.projectRoot}`);
+  lines.push(`- **Stack**: ${plan.stack}${plan.stackOverridden ? ' (via --stack)' : ''}`);
   if (plan.primarySubpackage) {
     lines.push(`- **Primary subpackage**: ${plan.primarySubpackage}`);
   }
@@ -492,9 +457,7 @@ export function renderPlanSummary(plan: InitPlan, opts: { verbose?: boolean } =
   lines.push('|------|-------------|--------|-----------------|');
   for (const m of plan.mappings) {
     if (m.runCommand) {
-      lines.push(
-        `| \`${m.verb}\` | \`${m.nativeTask}\` | ${m.reason} | \`${m.runCommand}\` |`,
-      );
+      lines.push(`| \`${m.verb}\` | \`${m.nativeTask}\` | ${m.reason} | \`${m.runCommand}\` |`);
     } else {
       lines.push(`| \`${m.verb}\` | _(not found)_ | not-found | _(skipped)_ |`);
     }
@@ -506,9 +469,7 @@ export function renderPlanSummary(plan: InitPlan, opts: { verbose?: boolean } =
     lines.push('');
     for (const m of withAlts) {
       const alts = m.alternatives.map((a) => `\`${a}\``).join(', ');
-      lines.push(
-        `- \`${m.verb}\` chose \`${m.nativeTask}\` (${m.reason}); also matched: ${alts}`,
-      );
+      lines.push(`- \`${m.verb}\` chose \`${m.nativeTask}\` (${m.reason}); also matched: ${alts}`);
     }
     lines.push('');
   }

package/src/manifest.ts

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as TOML from 'smol-toml';
 import YAML from 'js-yaml';
+import { at, dict, type Dict } from './narrow.ts';
 
 export interface VdxManifest {
   schema_version?: string;
@@ -29,18 +30,38 @@ export interface Override {
   until?: string;
 }
 
-export function loadManifest(projectRoot: string): VdxManifest | null {
+/**
+ * Where the manifest lives in mise.toml. `[_.vdx]` — mise documents the `[_]` table as never
+ * read, for other tools' data. `[vdx]` — where it lived before vdx 0.26; still read, but mise
+ * 2026.10 warns about an unknown field on every run.
+ */
+export type ManifestPlace = '_.vdx' | 'vdx';
+
+/** The manifest table of a parsed mise.toml and its place: `[_.vdx]`, else the older `[vdx]`. */
+export function manifestTable(data: unknown): { table: Dict; place: ManifestPlace } | null {
+  const table = dict(at(data, '_', 'vdx'));
+  if (table) return { table, place: '_.vdx' };
+  const older = dict(at(data, 'vdx'));
+  return older ? { table: older, place: 'vdx' } : null;
+}
+
+/** The project's manifest and where in its mise.toml it was found. */
+export function loadManifestAt(projectRoot: string): { manifest: VdxManifest; place: ManifestPlace } | null {
   const miseToml = path.join(projectRoot, 'mise.toml');
   if (!fs.existsSync(miseToml)) return null;
   try {
-    const text = fs.readFileSync(miseToml, 'utf8');
-    const data = TOML.parse(text) as { vdx?: VdxManifest };
-    return data?.vdx ?? null;
+    const found = manifestTable(TOML.parse(fs.readFileSync(miseToml, 'utf8')));
+    // The fields are the project's to write; readers check what they use.
+    return found ? { manifest: found.table, place: found.place } : null;
   } catch {
     return null;
   }
 }
 
+export function loadManifest(projectRoot: string): VdxManifest | null {
+  return loadManifestAt(projectRoot)?.manifest ?? null;
+}
+
 export function loadOverrides(projectRoot: string): Override[] {
   const file = path.join(projectRoot, '.vdx-overrides.yml');
   if (!fs.existsSync(file)) return [];

package/src/mcp-server.ts

@@ -8,12 +8,13 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import * as TOML from 'smol-toml';
 
 import { loadRubric } from './rubric.ts';
-import { loadManifest, loadOverrides } from './manifest.ts';
+import { loadManifest, loadOverrides, manifestTable } from './manifest.ts';
 import { autoDetectStack, readToml, type Ctx } from './facts.ts';
 import { audit } from './audit.ts';
 import { reportJson, reportMarkdown } from './report.ts';
 import { DEFAULT_BASELINE, STANDARD_VERBS, type Verb } from './init.ts';
 import { resolveDefaultRubric } from './defaults.ts';
+import { at, dict, errorMessage, isStringList, str, type Dict } from './narrow.ts';
 
 const DEFAULT_RUBRIC = resolveDefaultRubric();
 
@@ -30,18 +31,16 @@ function freshCtx(): Ctx {
   return { projectRoot: PROJECT_ROOT, stack, cache: new Map() };
 }
 
-function readMiseToml(): any {
+function readMiseToml(): unknown {
   return readToml(freshCtx(), 'mise.toml');
 }
 
-function getVdxBlock(): any {
-  const t = readMiseToml();
-  return t?.vdx ?? null;
+function getVdxBlock(): Dict | null {
+  return manifestTable(readMiseToml())?.table ?? null;
 }
 
-function getTasks(): Record<string, any> {
-  const t = readMiseToml();
-  return (t?.tasks as Record<string, any>) ?? {};
+function getTasks(): Dict {
+  return dict(at(readMiseToml(), 'tasks')) ?? {};
 }
 
 interface RunResult {
@@ -61,10 +60,10 @@ function spawnVerb(verb: Verb, extraArgs: string[]): Promise<RunResult> {
     });
     let stdout = '';
     let stderr = '';
-    child.stdout.on('data', (b) => {
+    child.stdout.on('data', (b: Buffer) => {
       stdout += b.toString();
     });
-    child.stderr.on('data', (b) => {
+    child.stderr.on('data', (b: Buffer) => {
       stderr += b.toString();
     });
     child.on('error', (e) => {
@@ -91,33 +90,33 @@ function spawnVerb(verb: Verb, extraArgs: string[]): Promise<RunResult> {
 function buildCapabilities() {
   const vdxBlock = getVdxBlock();
   const tasks = getTasks();
-  const verbsList = (vdxBlock?.verbs as string[] | undefined) ?? STANDARD_VERBS.slice();
+  const declared = vdxBlock?.['verbs'];
+  const verbsList = isStringList(declared) ? declared : STANDARD_VERBS.slice();
   const verbs = verbsList.map((name) => {
     const t = tasks[name];
-    const nativeCommand =
-      t && typeof t === 'object' && typeof t.run === 'string' ? t.run : null;
     return {
       name,
       has_manifest: Boolean(t),
-      native_command: nativeCommand,
+      native_command: str(at(t, 'run')) ?? null,
     };
   });
 
-  const sharedInfra = vdxBlock?.shared_infra
+  const infra = dict(vdxBlock?.['shared_infra']);
+  const sharedInfra = infra
     ? {
-        provider: String(vdxBlock.shared_infra.provider ?? ''),
-        precheck: Boolean(vdxBlock.shared_infra.precheck),
+        provider: str(infra['provider']) ?? '',
+        precheck: Boolean(infra['precheck']),
         is_running: false,
       }
     : null;
 
   return {
-    schema_version: String(vdxBlock?.schema_version ?? '0.2'),
-    stack: String(vdxBlock?.stack ?? autoDetectStack(PROJECT_ROOT)),
-    baseline: String(vdxBlock?.baseline ?? `file://${DEFAULT_RUBRIC}`),
+    schema_version: str(vdxBlock?.['schema_version']) ?? '0.2',
+    stack: str(vdxBlock?.['stack']) ?? autoDetectStack(PROJECT_ROOT),
+    baseline: str(vdxBlock?.['baseline']) ?? `file://${DEFAULT_RUBRIC}`,
     verbs,
     shared_infra: sharedInfra,
-    last_verified: vdxBlock?.success_path?.last_verified ?? null,
+    last_verified: at(vdxBlock, 'success_path', 'last_verified') ?? null,
   };
 }
 
@@ -139,40 +138,44 @@ function recordSuccessPath(input: {
   notes?: string;
 }): { ok: boolean; manifest_path: string; agents_md_updated: boolean } {
   const manifestPath = path.join(PROJECT_ROOT, 'mise.toml');
-  let doc: any = {};
+  let doc: Dict = {};
   if (fs.existsSync(manifestPath)) {
     const text = fs.readFileSync(manifestPath, 'utf8');
     try {
       doc = TOML.parse(text);
-    } catch (e: any) {
-      throw new Error(`mise.toml parse error: ${e?.message}`);
+    } catch (e) {
+      throw new Error(`mise.toml parse error: ${errorMessage(e)}`, { cause: e });
     }
   }
 
-  doc.tasks = doc.tasks ?? {};
+  const tasks = dict(doc['tasks']) ?? {};
   for (const v of input.verbs) {
-    doc.tasks[v.name] = { run: v.command };
+    tasks[v.name] = { run: v.command };
   }
+  doc['tasks'] = tasks;
 
-  doc.vdx = doc.vdx ?? {
+  // An existing manifest is updated where it is; a new one goes into [_.vdx].
+  const found = manifestTable(doc);
+  const vdx = found?.table ?? {
     schema_version: '0.2',
     baseline: DEFAULT_BASELINE,
     stack: autoDetectStack(PROJECT_ROOT),
   };
-  doc.vdx.verbs = input.verbs.map((v) => v.name);
+  vdx['verbs'] = input.verbs.map((v) => v.name);
 
   if (input.shared_infra) {
-    doc.vdx.shared_infra = {
+    vdx['shared_infra'] = {
       provider: input.shared_infra.provider,
       precheck: input.shared_infra.precheck,
     };
   }
 
-  doc.vdx.success_path = {
+  vdx['success_path'] = {
     last_verified: new Date().toISOString().slice(0, 10),
     verified_by: 'vdx-mcp',
     ...(input.notes ? { notes: input.notes } : {}),
   };
+  if (!found) doc['_'] = { ...dict(doc['_']), vdx };
 
   const newText = TOML.stringify(doc);
   fs.writeFileSync(manifestPath, newText, 'utf8');
@@ -192,7 +195,7 @@ server.registerTool(
       'Возвращает manifest проекта: stack, baseline, доступные глаголы и их native команды, shared_infra и last_verified. Самый частый вызов агента, входящего в проект.',
     inputSchema: {},
   },
-  async () => {
+  () => {
     const payload = buildCapabilities();
     return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
   },
@@ -222,7 +225,7 @@ server.registerTool(
       format: z.enum(['json', 'markdown']).optional(),
     },
   },
-  async ({ baseline, format }) => {
+  ({ baseline, format }) => {
     const fmt = format ?? 'json';
     const payload = buildAuditPayload(baseline, fmt);
     return { content: [{ type: 'text', text: payload }] };
@@ -233,16 +236,14 @@ server.registerTool(
   'vdx_record_success_path',
   {
     description:
-      'Записывает обнаруженные команды в [tasks.X] секцию mise.toml + обновляет [vdx.success_path]. Используется после успешной верификации команд агентом.',
+      'Записывает обнаруженные команды в [tasks.X] секцию mise.toml + обновляет [_.vdx.success_path] (у манифеста в старом [vdx] — там). Используется после успешной верификации команд агентом.',
     inputSchema: {
       verbs: z.array(z.object({ name: z.string(), command: z.string() })),
-      shared_infra: z
-        .object({ provider: z.string(), precheck: z.boolean() })
-        .optional(),
+      shared_infra: z.object({ provider: z.string(), precheck: z.boolean() }).optional(),
       notes: z.string().optional(),
     },
   },
-  async ({ verbs, shared_infra, notes }) => {
+  ({ verbs, shared_infra, notes }) => {
     const args: Parameters<typeof recordSuccessPath>[0] = { verbs };
     if (shared_infra) args.shared_infra = shared_infra;
     if (notes !== undefined) args.notes = notes;
@@ -257,7 +258,7 @@ async function main() {
   process.stderr.write(`vdx-mcp connected (project: ${PROJECT_ROOT})\n`);
 }
 
-main().catch((e) => {
-  process.stderr.write(`vdx-mcp fatal: ${e?.message ?? e}\n`);
+main().catch((e: unknown) => {
+  process.stderr.write(`vdx-mcp fatal: ${errorMessage(e)}\n`);
   process.exit(1);
 });