@intentius/chant 0.0.4 → 0.0.8

package/src/cli/commands/import.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
 import { join, resolve, basename } from "path";
 import { formatSuccess, formatWarning, formatError } from "../format";
 import type { TemplateIR, ResourceIR, TemplateParser } from "../../import/parser";
@@ -266,7 +266,7 @@ export async function importCommand(options: ImportOptions): Promise<ImportResul
 
   // Check output directory
   if (existsSync(outputDir) && !options.force) {
-    const files = require("fs").readdirSync(outputDir);
+    const files = readdirSync(outputDir);
     if (files.length > 0) {
       warnings.push(`Output directory ${outputDir} is not empty. Use --force to overwrite.`);
     }

package/src/cli/commands/init-lexicon.test.ts

@@ -40,7 +40,6 @@ describe("initLexiconCommand", () => {
       "src/codegen/generate-cli.ts",
       "src/codegen/naming.ts",
       "src/codegen/package.ts",
-      "src/codegen/rollback.ts",
       "src/codegen/docs.ts",
       "src/spec/fetch.ts",
       "src/spec/parse.ts",
@@ -65,7 +64,6 @@ describe("initLexiconCommand", () => {
       "docs/src/content/docs/index.mdx",
       "src/generated/.gitkeep",
       "examples/getting-started/.gitkeep",
-      ".snapshots/.gitkeep",
     ];
 
     for (const file of expectedFiles) {
@@ -83,7 +81,6 @@ describe("initLexiconCommand", () => {
     expect(pluginContent).toContain("async validate(");
     expect(pluginContent).toContain("async coverage(");
     expect(pluginContent).toContain("async package(");
-    expect(pluginContent).toContain("async rollback(");
   });
 
   test("package name uses the provided lexicon name", async () => {

package/src/cli/commands/init-lexicon.ts

@@ -83,7 +83,9 @@ export const ${names.pluginVarName}: LexiconPlugin = {
 
   async validate(options?: { verbose?: boolean }): Promise<void> {
     const { validate } = await import("./validate");
-    await validate(options);
+    const { printValidationResult } = await import("@intentius/chant/codegen/validate");
+    const result = await validate();
+    printValidationResult(result);
   },
 
   async coverage(options?: { verbose?: boolean; minOverall?: number }): Promise<void> {
@@ -93,32 +95,15 @@ export const ${names.pluginVarName}: LexiconPlugin = {
 
   async package(options?: { verbose?: boolean; force?: boolean }): Promise<void> {
     const { packageLexicon } = await import("./codegen/package");
-    await packageLexicon(options);
-  },
-
-  async rollback(options?: { restore?: string; verbose?: boolean }): Promise<void> {
-    const { listSnapshots, restoreSnapshot } = await import("./codegen/rollback");
+    const { writeBundleSpec } = await import("@intentius/chant/codegen/package");
     const { join, dirname } = await import("path");
     const { fileURLToPath } = await import("url");
 
+    const { spec, stats } = await packageLexicon(options);
     const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
-    const snapshotsDir = join(pkgDir, ".snapshots");
-
-    if (options?.restore) {
-      const generatedDir = join(pkgDir, "src", "generated");
-      restoreSnapshot(String(options.restore), generatedDir);
-      console.error(\`Restored snapshot: \${options.restore}\`);
-    } else {
-      const snapshots = listSnapshots(snapshotsDir);
-      if (snapshots.length === 0) {
-        console.error("No snapshots available.");
-      } else {
-        console.error(\`Available snapshots (\${snapshots.length}):\`);
-        for (const s of snapshots) {
-          console.error(\`  \${s.timestamp}  \${s.resources} resources  \${s.path}\`);
-        }
-      }
-    }
+    writeBundleSpec(spec, join(pkgDir, "dist"));
+
+    console.error(\`Packaged \${stats.resources} resources, \${stats.ruleCount} rules, \${stats.skillCount} skills\`);
   },
 
   // ── Optional extensions (uncomment and implement as needed) ───
@@ -372,55 +357,6 @@ export async function packageLexicon(options?: { verbose?: boolean; force?: bool
 `;
 }
 
-function generateCodegenRollbackTs(): string {
-  return `import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync } from "fs";
-import { join, basename } from "path";
-
-export interface Snapshot {
-  timestamp: string;
-  resources: number;
-  path: string;
-}
-
-/**
- * List available generation snapshots.
- */
-export function listSnapshots(snapshotsDir: string): Snapshot[] {
-  if (!existsSync(snapshotsDir)) return [];
-
-  return readdirSync(snapshotsDir)
-    .filter((d) => !d.startsWith("."))
-    .sort()
-    .reverse()
-    .map((dir) => {
-      const fullPath = join(snapshotsDir, dir);
-      const metaPath = join(fullPath, "meta.json");
-      let resources = 0;
-      if (existsSync(metaPath)) {
-        try {
-          const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-          resources = meta.resources ?? 0;
-        } catch {}
-      }
-      return { timestamp: dir, resources, path: fullPath };
-    });
-}
-
-/**
- * Restore a snapshot to the generated directory.
- */
-export function restoreSnapshot(timestamp: string, generatedDir: string): void {
-  const snapshotsDir = join(generatedDir, "..", "..", ".snapshots");
-  const snapshotDir = join(snapshotsDir, timestamp);
-  if (!existsSync(snapshotDir)) {
-    throw new Error(\`Snapshot not found: \${timestamp}\`);
-  }
-  mkdirSync(generatedDir, { recursive: true });
-  cpSync(snapshotDir, generatedDir, { recursive: true });
-}
-`;
-}
-
 function generateCodegenDocsTs(name: string): string {
   return `import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
 
@@ -612,28 +548,32 @@ export async function analyzeCoverage(options?: { verbose?: boolean }): Promise<
 
 function generateValidateTs(name: string): string {
   return `/**
- * Validate generated artifacts for the ${name} lexicon.
+ * Validate generated lexicon-${name} artifacts.
  *
- * TODO: Add validation checks for your generated files.
+ * Thin wrapper around the core validation framework
+ * with ${name}-specific configuration.
  */
-export async function validate(options?: { verbose?: boolean }): Promise<void> {
-  const checks = [
-    // TODO: Add checks — e.g. verify lexicon JSON exists, types compile,
-    // registry has expected resources, etc.
-    { name: "placeholder", ok: true, error: undefined as string | undefined },
-  ];
 
-  for (const check of checks) {
-    const status = check.ok ? "OK" : "FAIL";
-    const msg = check.error ? \` — \${check.error}\` : "";
-    console.error(\`  [\${status}] \${check.name}\${msg}\`);
-  }
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { validateLexiconArtifacts, type ValidateResult } from "@intentius/chant/codegen/validate";
 
-  const failed = checks.filter((c) => !c.ok);
-  if (failed.length > 0) {
-    throw new Error("Validation failed");
-  }
-  console.error("All validation checks passed.");
+export type { ValidateCheck, ValidateResult } from "@intentius/chant/codegen/validate";
+
+// TODO: Add names of required entities for your lexicon
+const REQUIRED_NAMES: string[] = [];
+
+/**
+ * Validate the generated lexicon-${name} artifacts.
+ */
+export async function validate(opts?: { basePath?: string }): Promise<ValidateResult> {
+  const basePath = opts?.basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
+
+  return validateLexiconArtifacts({
+    lexiconJsonFilename: "lexicon-${name}.json",
+    requiredNames: REQUIRED_NAMES,
+    basePath,
+  });
 }
 `;
 }
@@ -721,8 +661,7 @@ package: generate validate
 }
 
 function generateGitignore(): string {
-  return `.snapshots/
-dist/
+  return `dist/
 node_modules/
 .cache/
 `;
@@ -885,7 +824,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "docs/src/content",
     "docs/src/content/docs",
     "examples/getting-started",
-    ".snapshots",
   ];
 
   for (const dir of dirs) {
@@ -904,7 +842,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "src/codegen/generate-cli.ts": generateCodegenGenerateCliTs(),
     "src/codegen/naming.ts": generateCodegenNamingTs(),
     "src/codegen/package.ts": generateCodegenPackageTs(name),
-    "src/codegen/rollback.ts": generateCodegenRollbackTs(),
     "src/codegen/docs.ts": generateCodegenDocsTs(name),
     "src/spec/fetch.ts": generateSpecFetchTs(),
     "src/spec/parse.ts": generateSpecParseTs(),
@@ -933,7 +870,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
   const gitkeeps = [
     "src/generated/.gitkeep",
     "examples/getting-started/.gitkeep",
-    ".snapshots/.gitkeep",
   ];
 
   for (const gk of gitkeeps) {

package/src/cli/commands/init.test.ts

@@ -22,14 +22,13 @@ describe("initCommand", () => {
       expect(result.createdFiles).toContain("tsconfig.json");
       expect(result.createdFiles).toContain("chant.config.ts");
       expect(result.createdFiles).toContain(".gitignore");
-      expect(result.createdFiles).toContain("src/_.ts");
       expect(result.createdFiles).toContain("src/config.ts");
       expect(result.createdFiles).toContain("src/data-bucket.ts");
       expect(result.createdFiles).toContain("src/logs-bucket.ts");
     });
   });
 
-  test("aws source files use namespace imports", async () => {
+  test("aws source files use direct imports", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -41,15 +40,15 @@ describe("initCommand", () => {
       await initCommand(options);
 
       const configContent = readFileSync(join(testDir, "src", "config.ts"), "utf-8");
-      expect(configContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
+      expect(configContent).toContain('from "@intentius/chant-lexicon-aws"');
 
       const dataBucketContent = readFileSync(join(testDir, "src", "data-bucket.ts"), "utf-8");
-      expect(dataBucketContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
-      expect(dataBucketContent).toContain('import * as _ from "./_"');
+      expect(dataBucketContent).toContain('from "@intentius/chant-lexicon-aws"');
+      expect(dataBucketContent).toContain('from "./config"');
 
       const logsBucketContent = readFileSync(join(testDir, "src", "logs-bucket.ts"), "utf-8");
-      expect(logsBucketContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
-      expect(logsBucketContent).toContain('import * as _ from "./_"');
+      expect(logsBucketContent).toContain('from "@intentius/chant-lexicon-aws"');
+      expect(logsBucketContent).toContain('from "./config"');
     });
   });
 
@@ -177,7 +176,7 @@ describe("initCommand", () => {
     });
   });
 
-  test("generates barrel file", async () => {
+  test("does not generate barrel file", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -188,13 +187,11 @@ describe("initCommand", () => {
 
       await initCommand(options);
 
+      // No _.ts barrel — direct imports are used instead
       const barrelPath = join(testDir, "src", "_.ts");
-      expect(existsSync(barrelPath)).toBe(true);
+      expect(existsSync(barrelPath)).toBe(false);
 
-      const barrelContent = readFileSync(barrelPath, "utf-8");
-      expect(barrelContent).toContain('export * from "./config"');
-
-      // No index.ts — barrel re-exports cause duplicate entity errors during build
+      // No index.ts either
       const indexPath = join(testDir, "src", "index.ts");
       expect(existsSync(indexPath)).toBe(false);
     });
@@ -218,7 +215,6 @@ describe("initCommand", () => {
       expect(coreContent).toContain("Value<T>");
       expect(coreContent).toContain("Serializer");
       expect(coreContent).toContain("ChantConfig");
-      expect(coreContent).toContain("barrel");
 
       const corePkg = join(testDir, ".chant", "types", "core", "package.json");
       expect(existsSync(corePkg)).toBe(true);

package/src/cli/commands/init.ts

@@ -214,8 +214,6 @@ export interface ChantConfig {
   };
 }
 
-/** Barrel proxy — lazy-loads all sibling exports */
-export declare function barrel(dir: string): Record<string, unknown>;
 `;
 }
 
@@ -345,7 +343,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     warnings,
   );
 
-  // Generate source files from plugin (or fallback to a minimal barrel)
+  // Generate source files from plugin (if available)
   let sourceFiles: Record<string, string> = {};
   try {
     const plugin = await loadPlugin(options.lexicon);
@@ -353,10 +351,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
       sourceFiles = plugin.initTemplates();
     }
   } catch {
-    // Plugin not yet installed — write a minimal barrel stub
-    sourceFiles = {
-      "_.ts": "// Barrel — re-export shared config here\n",
-    };
+    // Plugin not yet installed — no source files to scaffold
   }
   for (const [filename, content] of Object.entries(sourceFiles)) {
     writeIfNotExists(
@@ -431,18 +426,29 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
   }
 
   // Install skills from the lexicon's plugin
+  // Write to both .chant/skills/ (chant's own location) and .claude/skills/ (Claude Code discovery)
   try {
     const plugin = await loadPlugin(options.lexicon);
     if (plugin.skills) {
       const skills = plugin.skills();
       if (skills.length > 0) {
-        const skillsDir = join(targetDir, ".chant", "skills", options.lexicon);
-        mkdirSync(skillsDir, { recursive: true });
+        // .chant/skills/ — chant's own skill storage
+        const chantSkillsDir = join(targetDir, ".chant", "skills", options.lexicon);
+        mkdirSync(chantSkillsDir, { recursive: true });
         for (const skill of skills) {
-          const skillPath = join(skillsDir, `${skill.name}.md`);
+          const skillPath = join(chantSkillsDir, `${skill.name}.md`);
           writeFileSync(skillPath, skill.content);
           createdFiles.push(`.chant/skills/${options.lexicon}/${skill.name}.md`);
         }
+
+        // .claude/skills/ — Claude Code skill discovery format
+        for (const skill of skills) {
+          const claudeSkillDir = join(targetDir, ".claude", "skills", skill.name);
+          mkdirSync(claudeSkillDir, { recursive: true });
+          const claudeSkillPath = join(claudeSkillDir, "SKILL.md");
+          writeFileSync(claudeSkillPath, skill.content);
+          createdFiles.push(`.claude/skills/${skill.name}/SKILL.md`);
+        }
       }
     }
   } catch {

package/src/cli/commands/lint.ts

@@ -1,7 +1,7 @@
 import { resolve, join } from "path";
 import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
 import { runLint } from "../../lint/engine";
-import type { LintRule, LintDiagnostic, LintFix, LintRunOptions } from "../../lint/rule";
+import type { LintRule, LintDiagnostic, LintFix } from "../../lint/rule";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
 import { formatStylish, formatJson, formatSarif } from "../reporters/stylish";
 import { loadLocalRules } from "../../lint/rule-loader";
@@ -241,54 +241,30 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
   // Get all TypeScript files
   const files = getTypeScriptFiles(infraPath);
 
-  // Build barrel exports context for EVL008
-  let runOptions: LintRunOptions | undefined;
-  try {
-    const { scanProject } = require("../../project/scan");
-    const scan = scanProject(infraPath);
-    const barrelExports = new Set<string>(scan.exports.map((e: { name: string }) => e.name));
-    const projectExports = new Map<string, { file: string; className: string }>();
-    for (const exp of scan.exports) {
-      projectExports.set(exp.name, { file: exp.file, className: exp.className });
-    }
-    runOptions = { barrelExports, projectExports, projectScan: scan };
-  } catch {
-    // No barrel file found — EVL008/COR016 will be no-ops
-  }
-
   // Run lint — use per-file rules when overrides are present
   let diagnostics: LintDiagnostic[];
   if (options.rules) {
-    diagnostics = await runLint(files, options.rules, undefined, runOptions);
+    diagnostics = await runLint(files, options.rules, undefined);
   } else if (hasOverrides) {
     diagnostics = [];
     for (const file of files) {
       const relativePath = file.slice(infraPath.length + 1);
       const { rules: fileRules, ruleOptions } = getDefaultRules(infraPath, relativePath, allRules);
-      const fileDiagnostics = await runLint([file], fileRules, ruleOptions, runOptions);
+      const fileDiagnostics = await runLint([file], fileRules, ruleOptions);
       diagnostics.push(...fileDiagnostics);
     }
   } else {
     const { rules, ruleOptions } = getDefaultRules(infraPath, undefined, allRules);
-    diagnostics = await runLint(files, rules, ruleOptions, runOptions);
+    diagnostics = await runLint(files, rules, ruleOptions);
   }
 
   // Apply fixes if requested
   if (options.fix) {
-    // Handle cross-file write fixes (COR016) separately
-    for (const diag of diagnostics) {
-      if (diag.fix?.kind === "write-file" && diag.fix.params) {
-        const path = diag.fix.params.path as string;
-        const content = diag.fix.params.content as string;
-        writeFileSync(path, content, "utf-8");
-      }
-    }
-
-    // Group remaining fixes by file (exclude write-file fixes)
+    // Group fixes by file
     const fixesByFile = new Map<string, LintFix[]>();
 
     for (const diag of diagnostics) {
-      if (diag.fix && diag.fix.kind !== "write-file") {
+      if (diag.fix) {
         const existing = fixesByFile.get(diag.file) ?? [];
         existing.push(diag.fix);
         fixesByFile.set(diag.file, existing);
@@ -303,18 +279,18 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
     // Re-lint after fixes to get updated diagnostics
     let postFixDiagnostics: LintDiagnostic[];
     if (options.rules) {
-      postFixDiagnostics = await runLint(files, options.rules, undefined, runOptions);
+      postFixDiagnostics = await runLint(files, options.rules, undefined);
     } else if (hasOverrides) {
       postFixDiagnostics = [];
       for (const file of files) {
         const relativePath = file.slice(infraPath.length + 1);
         const { rules: fileRules, ruleOptions } = getDefaultRules(infraPath, relativePath, allRules);
-        const fileDiagnostics = await runLint([file], fileRules, ruleOptions, runOptions);
+        const fileDiagnostics = await runLint([file], fileRules, ruleOptions);
         postFixDiagnostics.push(...fileDiagnostics);
       }
     } else {
       const { rules, ruleOptions } = getDefaultRules(infraPath, undefined, allRules);
-      postFixDiagnostics = await runLint(files, rules, ruleOptions, runOptions);
+      postFixDiagnostics = await runLint(files, rules, ruleOptions);
     }
     diagnostics.length = 0;
     diagnostics.push(...postFixDiagnostics);

package/src/cli/commands/list.ts

@@ -51,8 +51,8 @@ export async function listCommand(options: ListOptions): Promise<ListResult> {
   for (const [name, decl] of result.entities) {
     entities.push({
       name,
-      lexicon: decl.lexicon,
-      entityType: decl.entityType,
+      lexicon: decl.lexicon ?? "",
+      entityType: decl.entityType ?? "",
       kind: decl.kind ?? "resource",
     });
   }

package/src/cli/commands/update.ts

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, writeFileSync, cpSync, readdirSync, statSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync, cpSync, readdirSync, statSync, readFileSync } from "fs";
 import { join, resolve } from "path";
+import { createRequire } from "module";
 import { formatSuccess, formatWarning, formatError } from "../format";
 import { loadChantConfig } from "../../config";
 import { loadPlugins } from "../plugins";
@@ -63,13 +64,14 @@ function copyTypeFiles(src: string, dest: string): number {
 function resolvePackagePath(packageName: string, projectDir: string): string | undefined {
   // Try resolve from project dir
   try {
-    const entryPoint = require.resolve(packageName, { paths: [projectDir] });
+    const _require = createRequire(join(projectDir, "package.json"));
+    const entryPoint = _require.resolve(packageName);
     // Walk up from entry point to find package root
     let dir = entryPoint;
     while (dir !== "/") {
       dir = join(dir, "..");
       if (existsSync(join(dir, "package.json"))) {
-        const pkg = JSON.parse(require("fs").readFileSync(join(dir, "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
         if (pkg.name === packageName) return dir;
       }
     }

package/src/cli/conflict-check.test.ts

@@ -22,7 +22,6 @@ function makePlugin(
     validate: noopAsync,
     coverage: noopAsync,
     package: noopAsync,
-    rollback: noopAsync,
   };
 
   if (opts.rules) {

package/src/cli/handlers/dev.ts

@@ -21,18 +21,10 @@ export async function runDevPublish(ctx: CommandContext): Promise<number> {
   return 0;
 }
 
-export async function runDevRollback(ctx: CommandContext): Promise<number> {
-  for (const plugin of ctx.plugins) {
-    await plugin.rollback({ verbose: ctx.args.verbose });
-    console.error(formatSuccess(`${plugin.name}: rollback complete`));
-  }
-  return 0;
-}
-
 export async function runDevUnknown(ctx: CommandContext): Promise<number> {
   console.error(formatError({
     message: `Unknown dev subcommand: ${ctx.args.path}`,
-    hint: "Available: chant dev generate, chant dev publish, chant dev rollback",
+    hint: "Available: chant dev generate, chant dev publish",
   }));
   return 1;
 }

package/src/cli/main.ts

@@ -4,9 +4,11 @@ import { resolve } from "node:path";
 import { formatSuccess, formatError } from "./format";
 import { loadPlugins, resolveProjectLexicons } from "./plugins";
 import { resolveCommand, type CommandDef, type ParsedArgs } from "./registry";
+import { loadChantConfig } from "../config";
+import { initRuntime } from "../runtime-adapter";
 import { runBuild } from "./handlers/build";
 import { runLint } from "./handlers/lint";
-import { runDevGenerate, runDevPublish, runDevRollback, runDevUnknown } from "./handlers/dev";
+import { runDevGenerate, runDevPublish, runDevUnknown } from "./handlers/dev";
 import { runServeLsp, runServeMcp, runServeUnknown } from "./handlers/serve";
 import { runInit, runInitLexicon } from "./handlers/init";
 import { runList, runImport, runUpdate, runDoctor } from "./handlers/misc";
@@ -89,7 +91,6 @@ Commands:
 Lexicon development:
   dev generate          Generate lexicon artifacts (+ validate + coverage)
   dev publish           Package lexicon for distribution
-  dev rollback          List or restore generation snapshots
 
 Servers:
   serve lsp             Start the LSP server (stdio)
@@ -161,13 +162,12 @@ const registry: CommandDef[] = [
   { name: "import", handler: runImport },
   { name: "init", handler: runInit },
   { name: "init lexicon", handler: runInitLexicon },
-  { name: "update", handler: runUpdate },
+{ name: "update", handler: runUpdate },
   { name: "doctor", handler: runDoctor },
 
   // Dev subcommands
   { name: "dev generate", requiresPlugins: true, handler: runDevGenerate },
   { name: "dev publish", requiresPlugins: true, handler: runDevPublish },
-  { name: "dev rollback", requiresPlugins: true, handler: runDevRollback },
 
   // Serve subcommands
   { name: "serve lsp", requiresPlugins: true, handler: runServeLsp },
@@ -189,6 +189,16 @@ async function main(): Promise<void> {
     process.exit(args.help ? 0 : 1);
   }
 
+  // Initialize runtime adapter early — before plugins or commands run
+  const projectPath0 = resolve(args.path === "." ? "." : args.path);
+  try {
+    const { config } = await loadChantConfig(projectPath0);
+    initRuntime(config.runtime);
+  } catch {
+    // Config may not exist yet (e.g. `chant init`); auto-detect runtime
+    initRuntime();
+  }
+
   const match = resolveCommand(args, registry);
   if (!match) {
     console.error(formatError({