@gmickel/gno 0.7.0 → 0.8.2

package/src/cli/program.ts

@@ -5,28 +5,29 @@
  * @module src/cli/program
  */
 
-import { Command } from 'commander';
+import { Command } from "commander";
+
 import {
   CLI_NAME,
   DOCS_URL,
   ISSUES_URL,
   PRODUCT_NAME,
   VERSION,
-} from '../app/constants';
-import { setColorsEnabled } from './colors';
+} from "../app/constants";
+import { setColorsEnabled } from "./colors";
 import {
   applyGlobalOptions,
   type GlobalOptions,
   parseGlobalOptions,
-} from './context';
-import { CliError } from './errors';
+} from "./context";
+import { CliError } from "./errors";
 import {
   assertFormatSupported,
   CMD,
   getDefaultLimit,
   parseOptionalFloat,
   parsePositiveInt,
-} from './options';
+} from "./options";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Global State (set by preAction hook)
@@ -41,7 +42,7 @@ const globalState: { current: GlobalOptions | null } = { current: null };
  */
 export function getGlobals(): GlobalOptions {
   if (!globalState.current) {
-    throw new Error('Global options not resolved - called before preAction?');
+    throw new Error("Global options not resolved - called before preAction?");
   }
   return globalState.current;
 }
@@ -62,7 +63,7 @@ export function resetGlobals(): void {
  */
 function getFormat(
   cmdOpts: Record<string, unknown>
-): 'terminal' | 'json' | 'files' | 'csv' | 'md' | 'xml' {
+): "terminal" | "json" | "files" | "csv" | "md" | "xml" {
   const globals = getGlobals();
 
   const local = {
@@ -77,36 +78,36 @@ function getFormat(
   const localFormats = Object.entries(local).filter(([_, v]) => v);
   if (localFormats.length > 1) {
     throw new CliError(
-      'VALIDATION',
-      `Conflicting output formats: ${localFormats.map(([k]) => k).join(', ')}. Choose one.`
+      "VALIDATION",
+      `Conflicting output formats: ${localFormats.map(([k]) => k).join(", ")}. Choose one.`
     );
   }
 
   // Local non-json format wins (--md, --csv, --files, --xml)
   if (local.files) {
-    return 'files';
+    return "files";
   }
   if (local.csv) {
-    return 'csv';
+    return "csv";
   }
   if (local.md) {
-    return 'md';
+    return "md";
   }
   if (local.xml) {
-    return 'xml';
+    return "xml";
   }
 
   // Local --json wins over global
   if (local.json) {
-    return 'json';
+    return "json";
   }
 
   // Global --json as fallback
   if (globals.json) {
-    return 'json';
+    return "json";
   }
 
-  return 'terminal';
+  return "terminal";
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -119,24 +120,24 @@ export function createProgram(): Command {
   program
     .name(CLI_NAME)
     .description(`${PRODUCT_NAME} - Local Knowledge Index and Retrieval`)
-    .version(VERSION, '-V, --version', 'show version')
+    .version(VERSION, "-V, --version", "show version")
     .exitOverride() // Prevent Commander from calling process.exit()
     .showSuggestionAfterError(true)
-    .showHelpAfterError('(Use --help for available options)');
+    .showHelpAfterError("(Use --help for available options)");
 
   // Global flags - resolved via preAction hook
   program
-    .option('--index <name>', 'index name', 'default')
-    .option('--config <path>', 'config file path')
-    .option('--no-color', 'disable colors')
-    .option('--verbose', 'verbose logging')
-    .option('--yes', 'non-interactive mode')
-    .option('-q, --quiet', 'suppress non-essential output')
-    .option('--json', 'JSON output (for errors and supported commands)')
-    .option('--offline', 'offline mode (use cached models only)');
+    .option("--index <name>", "index name", "default")
+    .option("--config <path>", "config file path")
+    .option("--no-color", "disable colors")
+    .option("--verbose", "verbose logging")
+    .option("--yes", "non-interactive mode")
+    .option("-q, --quiet", "suppress non-essential output")
+    .option("--json", "JSON output (for errors and supported commands)")
+    .option("--offline", "offline mode (use cached models only)");
 
   // Resolve globals ONCE before any command runs (ensures consistency)
-  program.hook('preAction', (thisCommand) => {
+  program.hook("preAction", (thisCommand) => {
     const rootOpts = thisCommand.optsWithGlobals();
     const globals = parseGlobalOptions(rootOpts);
     applyGlobalOptions(globals);
@@ -154,7 +155,7 @@ export function createProgram(): Command {
 
   // Add docs/support links to help footer
   program.addHelpText(
-    'after',
+    "after",
     `
 Documentation: ${DOCS_URL}
 Report issues: ${ISSUES_URL}`
@@ -170,39 +171,39 @@ Report issues: ${ISSUES_URL}`
 function wireSearchCommands(program: Command): void {
   // search - BM25 keyword search
   program
-    .command('search <query>')
-    .description('BM25 keyword search')
-    .option('-n, --limit <num>', 'max results')
-    .option('--min-score <num>', 'minimum score threshold')
-    .option('-c, --collection <name>', 'filter by collection')
-    .option('--lang <code>', 'language filter/hint (BCP-47)')
-    .option('--full', 'include full content')
-    .option('--line-numbers', 'include line numbers in output')
-    .option('--json', 'JSON output')
-    .option('--md', 'Markdown output')
-    .option('--csv', 'CSV output')
-    .option('--xml', 'XML output')
-    .option('--files', 'file paths only')
+    .command("search <query>")
+    .description("BM25 keyword search")
+    .option("-n, --limit <num>", "max results")
+    .option("--min-score <num>", "minimum score threshold")
+    .option("-c, --collection <name>", "filter by collection")
+    .option("--lang <code>", "language filter/hint (BCP-47)")
+    .option("--full", "include full content")
+    .option("--line-numbers", "include line numbers in output")
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
+    .option("--csv", "CSV output")
+    .option("--xml", "XML output")
+    .option("--files", "file paths only")
     .action(async (queryText: string, cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.search, format);
 
       // Validate empty query
       if (!queryText.trim()) {
-        throw new CliError('VALIDATION', 'Query cannot be empty');
+        throw new CliError("VALIDATION", "Query cannot be empty");
       }
 
       // Validate minScore range
-      const minScore = parseOptionalFloat('min-score', cmdOpts.minScore);
+      const minScore = parseOptionalFloat("min-score", cmdOpts.minScore);
       if (minScore !== undefined && (minScore < 0 || minScore > 1)) {
-        throw new CliError('VALIDATION', '--min-score must be between 0 and 1');
+        throw new CliError("VALIDATION", "--min-score must be between 0 and 1");
       }
 
       const limit = cmdOpts.limit
-        ? parsePositiveInt('limit', cmdOpts.limit)
+        ? parsePositiveInt("limit", cmdOpts.limit)
         : getDefaultLimit(format);
 
-      const { search, formatSearch } = await import('./commands/search');
+      const { search, formatSearch } = await import("./commands/search");
       const result = await search(queryText, {
         limit,
         minScore,
@@ -210,28 +211,28 @@ function wireSearchCommands(program: Command): void {
         lang: cmdOpts.lang as string | undefined,
         full: Boolean(cmdOpts.full),
         lineNumbers: Boolean(cmdOpts.lineNumbers),
-        json: format === 'json',
-        md: format === 'md',
-        csv: format === 'csv',
-        xml: format === 'xml',
-        files: format === 'files',
+        json: format === "json",
+        md: format === "md",
+        csv: format === "csv",
+        xml: format === "xml",
+        files: format === "files",
       });
 
       // Check success before printing - stdout is for successful outputs only
       if (!result.success) {
         // Map validation errors to exit code 1
         throw new CliError(
-          result.isValidation ? 'VALIDATION' : 'RUNTIME',
+          result.isValidation ? "VALIDATION" : "RUNTIME",
           result.error
         );
       }
       process.stdout.write(
         `${formatSearch(result, {
-          json: format === 'json',
-          md: format === 'md',
-          csv: format === 'csv',
-          xml: format === 'xml',
-          files: format === 'files',
+          json: format === "json",
+          md: format === "md",
+          csv: format === "csv",
+          xml: format === "xml",
+          files: format === "files",
           full: Boolean(cmdOpts.full),
           lineNumbers: Boolean(cmdOpts.lineNumbers),
         })}\n`
@@ -240,39 +241,39 @@ function wireSearchCommands(program: Command): void {
 
   // vsearch - Vector similarity search
   program
-    .command('vsearch <query>')
-    .description('Vector similarity search')
-    .option('-n, --limit <num>', 'max results')
-    .option('--min-score <num>', 'minimum score threshold')
-    .option('-c, --collection <name>', 'filter by collection')
-    .option('--lang <code>', 'language filter/hint (BCP-47)')
-    .option('--full', 'include full content')
-    .option('--line-numbers', 'include line numbers in output')
-    .option('--json', 'JSON output')
-    .option('--md', 'Markdown output')
-    .option('--csv', 'CSV output')
-    .option('--xml', 'XML output')
-    .option('--files', 'file paths only')
+    .command("vsearch <query>")
+    .description("Vector similarity search")
+    .option("-n, --limit <num>", "max results")
+    .option("--min-score <num>", "minimum score threshold")
+    .option("-c, --collection <name>", "filter by collection")
+    .option("--lang <code>", "language filter/hint (BCP-47)")
+    .option("--full", "include full content")
+    .option("--line-numbers", "include line numbers in output")
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
+    .option("--csv", "CSV output")
+    .option("--xml", "XML output")
+    .option("--files", "file paths only")
     .action(async (queryText: string, cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.vsearch, format);
 
       // Validate empty query
       if (!queryText.trim()) {
-        throw new CliError('VALIDATION', 'Query cannot be empty');
+        throw new CliError("VALIDATION", "Query cannot be empty");
       }
 
       // Validate minScore range
-      const minScore = parseOptionalFloat('min-score', cmdOpts.minScore);
+      const minScore = parseOptionalFloat("min-score", cmdOpts.minScore);
       if (minScore !== undefined && (minScore < 0 || minScore > 1)) {
-        throw new CliError('VALIDATION', '--min-score must be between 0 and 1');
+        throw new CliError("VALIDATION", "--min-score must be between 0 and 1");
       }
 
       const limit = cmdOpts.limit
-        ? parsePositiveInt('limit', cmdOpts.limit)
+        ? parsePositiveInt("limit", cmdOpts.limit)
         : getDefaultLimit(format);
 
-      const { vsearch, formatVsearch } = await import('./commands/vsearch');
+      const { vsearch, formatVsearch } = await import("./commands/vsearch");
       const result = await vsearch(queryText, {
         limit,
         minScore,
@@ -280,23 +281,23 @@ function wireSearchCommands(program: Command): void {
         lang: cmdOpts.lang as string | undefined,
         full: Boolean(cmdOpts.full),
         lineNumbers: Boolean(cmdOpts.lineNumbers),
-        json: format === 'json',
-        md: format === 'md',
-        csv: format === 'csv',
-        xml: format === 'xml',
-        files: format === 'files',
+        json: format === "json",
+        md: format === "md",
+        csv: format === "csv",
+        xml: format === "xml",
+        files: format === "files",
       });
 
       if (!result.success) {
-        throw new CliError('RUNTIME', result.error);
+        throw new CliError("RUNTIME", result.error);
       }
       process.stdout.write(
         `${formatVsearch(result, {
-          json: format === 'json',
-          md: format === 'md',
-          csv: format === 'csv',
-          xml: format === 'xml',
-          files: format === 'files',
+          json: format === "json",
+          md: format === "md",
+          csv: format === "csv",
+          xml: format === "xml",
+          files: format === "files",
           full: Boolean(cmdOpts.full),
           lineNumbers: Boolean(cmdOpts.lineNumbers),
         })}\n`
@@ -305,41 +306,41 @@ function wireSearchCommands(program: Command): void {
 
   // query - Hybrid search with expansion and reranking
   program
-    .command('query <query>')
-    .description('Hybrid search with expansion and reranking')
-    .option('-n, --limit <num>', 'max results')
-    .option('--min-score <num>', 'minimum score threshold')
-    .option('-c, --collection <name>', 'filter by collection')
-    .option('--lang <code>', 'language hint (BCP-47)')
-    .option('--full', 'include full content')
-    .option('--line-numbers', 'include line numbers in output')
-    .option('--fast', 'skip expansion and reranking (fastest, ~0.7s)')
-    .option('--thorough', 'enable query expansion (slower, ~5-8s)')
-    .option('--no-expand', 'disable query expansion')
-    .option('--no-rerank', 'disable reranking')
-    .option('--explain', 'include scoring explanation')
-    .option('--json', 'JSON output')
-    .option('--md', 'Markdown output')
-    .option('--csv', 'CSV output')
-    .option('--xml', 'XML output')
-    .option('--files', 'file paths only')
+    .command("query <query>")
+    .description("Hybrid search with expansion and reranking")
+    .option("-n, --limit <num>", "max results")
+    .option("--min-score <num>", "minimum score threshold")
+    .option("-c, --collection <name>", "filter by collection")
+    .option("--lang <code>", "language hint (BCP-47)")
+    .option("--full", "include full content")
+    .option("--line-numbers", "include line numbers in output")
+    .option("--fast", "skip expansion and reranking (fastest, ~0.7s)")
+    .option("--thorough", "enable query expansion (slower, ~5-8s)")
+    .option("--no-expand", "disable query expansion")
+    .option("--no-rerank", "disable reranking")
+    .option("--explain", "include scoring explanation")
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
+    .option("--csv", "CSV output")
+    .option("--xml", "XML output")
+    .option("--files", "file paths only")
     .action(async (queryText: string, cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.query, format);
 
       // Validate empty query
       if (!queryText.trim()) {
-        throw new CliError('VALIDATION', 'Query cannot be empty');
+        throw new CliError("VALIDATION", "Query cannot be empty");
       }
 
       // Validate minScore range
-      const minScore = parseOptionalFloat('min-score', cmdOpts.minScore);
+      const minScore = parseOptionalFloat("min-score", cmdOpts.minScore);
       if (minScore !== undefined && (minScore < 0 || minScore > 1)) {
-        throw new CliError('VALIDATION', '--min-score must be between 0 and 1');
+        throw new CliError("VALIDATION", "--min-score must be between 0 and 1");
       }
 
       const limit = cmdOpts.limit
-        ? parsePositiveInt('limit', cmdOpts.limit)
+        ? parsePositiveInt("limit", cmdOpts.limit)
         : getDefaultLimit(format);
 
       // Determine expansion/rerank settings based on flags
@@ -366,7 +367,7 @@ function wireSearchCommands(program: Command): void {
         }
       }
 
-      const { query, formatQuery } = await import('./commands/query');
+      const { query, formatQuery } = await import("./commands/query");
       const result = await query(queryText, {
         limit,
         minScore,
@@ -377,15 +378,15 @@ function wireSearchCommands(program: Command): void {
         noExpand,
         noRerank,
         explain: Boolean(cmdOpts.explain),
-        json: format === 'json',
-        md: format === 'md',
-        csv: format === 'csv',
-        xml: format === 'xml',
-        files: format === 'files',
+        json: format === "json",
+        md: format === "md",
+        csv: format === "csv",
+        xml: format === "xml",
+        files: format === "files",
       });
 
       if (!result.success) {
-        throw new CliError('RUNTIME', result.error);
+        throw new CliError("RUNTIME", result.error);
       }
       process.stdout.write(
         `${formatQuery(result, {
@@ -398,35 +399,35 @@ function wireSearchCommands(program: Command): void {
 
   // ask - Human-friendly query with grounded answer
   program
-    .command('ask <query>')
-    .description('Human-friendly query with grounded answer')
-    .option('-n, --limit <num>', 'max source results')
-    .option('-c, --collection <name>', 'filter by collection')
-    .option('--lang <code>', 'language hint (BCP-47)')
-    .option('--fast', 'skip expansion and reranking (fastest)')
-    .option('--thorough', 'enable query expansion (slower)')
-    .option('--answer', 'generate short grounded answer')
-    .option('--no-answer', 'force retrieval-only output')
-    .option('--max-answer-tokens <num>', 'max answer tokens')
-    .option('--show-sources', 'show all retrieved sources (not just cited)')
-    .option('--json', 'JSON output')
-    .option('--md', 'Markdown output')
+    .command("ask <query>")
+    .description("Human-friendly query with grounded answer")
+    .option("-n, --limit <num>", "max source results")
+    .option("-c, --collection <name>", "filter by collection")
+    .option("--lang <code>", "language hint (BCP-47)")
+    .option("--fast", "skip expansion and reranking (fastest)")
+    .option("--thorough", "enable query expansion (slower)")
+    .option("--answer", "generate short grounded answer")
+    .option("--no-answer", "force retrieval-only output")
+    .option("--max-answer-tokens <num>", "max answer tokens")
+    .option("--show-sources", "show all retrieved sources (not just cited)")
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
     .action(async (queryText: string, cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.ask, format);
 
       // Validate empty query
       if (!queryText.trim()) {
-        throw new CliError('VALIDATION', 'Query cannot be empty');
+        throw new CliError("VALIDATION", "Query cannot be empty");
       }
 
       const limit = cmdOpts.limit
-        ? parsePositiveInt('limit', cmdOpts.limit)
+        ? parsePositiveInt("limit", cmdOpts.limit)
         : getDefaultLimit(format);
 
       // Parse max-answer-tokens (optional, defaults to 512 in command impl)
       const maxAnswerTokens = cmdOpts.maxAnswerTokens
-        ? parsePositiveInt('max-answer-tokens', cmdOpts.maxAnswerTokens)
+        ? parsePositiveInt("max-answer-tokens", cmdOpts.maxAnswerTokens)
         : undefined;
 
       // Determine expansion/rerank settings based on flags
@@ -442,7 +443,7 @@ function wireSearchCommands(program: Command): void {
         noRerank = false;
       }
 
-      const { ask, formatAsk } = await import('./commands/ask');
+      const { ask, formatAsk } = await import("./commands/ask");
       const showSources = Boolean(cmdOpts.showSources);
       const result = await ask(queryText, {
         limit,
@@ -456,15 +457,15 @@ function wireSearchCommands(program: Command): void {
         noAnswer: Boolean(cmdOpts.noAnswer),
         maxAnswerTokens,
         showSources,
-        json: format === 'json',
-        md: format === 'md',
+        json: format === "json",
+        md: format === "md",
       });
 
       if (!result.success) {
-        throw new CliError('RUNTIME', result.error);
+        throw new CliError("RUNTIME", result.error);
       }
       process.stdout.write(
-        `${formatAsk(result, { json: format === 'json', md: format === 'md', showSources })}\n`
+        `${formatAsk(result, { json: format === "json", md: format === "md", showSources })}\n`
       );
     });
 }
@@ -476,19 +477,19 @@ function wireSearchCommands(program: Command): void {
 function wireOnboardingCommands(program: Command): void {
   // init - Initialize GNO
   program
-    .command('init [path]')
-    .description('Initialize GNO configuration')
-    .option('-n, --name <name>', 'collection name')
-    .option('--pattern <glob>', 'file matching pattern')
-    .option('--include <exts>', 'extension allowlist (CSV)')
-    .option('--exclude <patterns>', 'exclude patterns (CSV)')
-    .option('--update <cmd>', 'shell command to run before indexing')
-    .option('--tokenizer <type>', 'FTS tokenizer (unicode61, porter, trigram)')
-    .option('--language <code>', 'language hint (BCP-47)')
+    .command("init [path]")
+    .description("Initialize GNO configuration")
+    .option("-n, --name <name>", "collection name")
+    .option("--pattern <glob>", "file matching pattern")
+    .option("--include <exts>", "extension allowlist (CSV)")
+    .option("--exclude <patterns>", "exclude patterns (CSV)")
+    .option("--update <cmd>", "shell command to run before indexing")
+    .option("--tokenizer <type>", "FTS tokenizer (unicode61, porter, trigram)")
+    .option("--language <code>", "language hint (BCP-47)")
     .action(
       async (path: string | undefined, cmdOpts: Record<string, unknown>) => {
         const globals = getGlobals();
-        const { init } = await import('./commands/init');
+        const { init } = await import("./commands/init");
         const result = await init({
           path,
           name: cmdOpts.name as string | undefined,
@@ -497,27 +498,27 @@ function wireOnboardingCommands(program: Command): void {
           exclude: cmdOpts.exclude as string | undefined,
           update: cmdOpts.update as string | undefined,
           tokenizer: cmdOpts.tokenizer as
-            | 'unicode61'
-            | 'porter'
-            | 'trigram'
+            | "unicode61"
+            | "porter"
+            | "trigram"
             | undefined,
           language: cmdOpts.language as string | undefined,
           yes: globals.yes,
         });
 
         if (!result.success) {
-          throw new CliError('RUNTIME', result.error ?? 'Init failed');
+          throw new CliError("RUNTIME", result.error ?? "Init failed");
         }
 
         if (result.alreadyInitialized) {
-          process.stdout.write('GNO already initialized.\n');
+          process.stdout.write("GNO already initialized.\n");
           if (result.collectionAdded) {
             process.stdout.write(
               `Collection "${result.collectionAdded}" added.\n`
             );
           }
         } else {
-          process.stdout.write('GNO initialized successfully.\n');
+          process.stdout.write("GNO initialized successfully.\n");
           process.stdout.write(`Config: ${result.configPath}\n`);
           process.stdout.write(`Database: ${result.dbPath}\n`);
           if (result.collectionAdded) {
@@ -531,18 +532,18 @@ function wireOnboardingCommands(program: Command): void {
 
   // index - Index collections
   program
-    .command('index [collection]')
-    .description('Index files from collections')
-    .option('--no-embed', 'skip embedding after sync')
-    .option('--git-pull', 'run git pull in git repositories')
-    .option('--models-pull', 'download models if missing')
+    .command("index [collection]")
+    .description("Index files from collections")
+    .option("--no-embed", "skip embedding after sync")
+    .option("--git-pull", "run git pull in git repositories")
+    .option("--models-pull", "download models if missing")
     .action(
       async (
         collection: string | undefined,
         cmdOpts: Record<string, unknown>
       ) => {
         const globals = getGlobals();
-        const { index, formatIndex } = await import('./commands/index-cmd');
+        const { index, formatIndex } = await import("./commands/index-cmd");
         const opts = {
           collection,
           noEmbed: cmdOpts.embed === false,
@@ -554,7 +555,7 @@ function wireOnboardingCommands(program: Command): void {
         const result = await index(opts);
 
         if (!result.success) {
-          throw new CliError('RUNTIME', result.error ?? 'Index failed');
+          throw new CliError("RUNTIME", result.error ?? "Index failed");
         }
         process.stdout.write(`${formatIndex(result, opts)}\n`);
       }
@@ -562,37 +563,37 @@ function wireOnboardingCommands(program: Command): void {
 
   // status - Show index status
   program
-    .command('status')
-    .description('Show index status')
-    .option('--json', 'JSON output')
+    .command("status")
+    .description("Show index status")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.status, format);
 
-      const { status, formatStatus } = await import('./commands/status');
-      const result = await status({ json: format === 'json' });
+      const { status, formatStatus } = await import("./commands/status");
+      const result = await status({ json: format === "json" });
 
       if (!result.success) {
-        throw new CliError('RUNTIME', result.error ?? 'Status failed');
+        throw new CliError("RUNTIME", result.error ?? "Status failed");
       }
       process.stdout.write(
-        `${formatStatus(result, { json: format === 'json' })}\n`
+        `${formatStatus(result, { json: format === "json" })}\n`
       );
     });
 
   // doctor - Diagnose configuration issues
   program
-    .command('doctor')
-    .description('Diagnose configuration issues')
-    .option('--json', 'JSON output')
+    .command("doctor")
+    .description("Diagnose configuration issues")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
-      const { doctor, formatDoctor } = await import('./commands/doctor');
-      const result = await doctor({ json: format === 'json' });
+      const { doctor, formatDoctor } = await import("./commands/doctor");
+      const result = await doctor({ json: format === "json" });
 
       // Doctor always succeeds but may report issues
       process.stdout.write(
-        `${formatDoctor(result, { json: format === 'json' })}\n`
+        `${formatDoctor(result, { json: format === "json" })}\n`
       );
     });
 }
@@ -604,41 +605,41 @@ function wireOnboardingCommands(program: Command): void {
 function wireRetrievalCommands(program: Command): void {
   // get - Retrieve document by URI or docid
   program
-    .command('get <ref>')
-    .description('Get document by URI or docid')
+    .command("get <ref>")
+    .description("Get document by URI or docid")
     .option(
-      '--from <line>',
-      'Start at line number',
-      parsePositiveInt.bind(null, 'from')
+      "--from <line>",
+      "Start at line number",
+      parsePositiveInt.bind(null, "from")
     )
     .option(
-      '-l, --limit <lines>',
-      'Limit to N lines',
-      parsePositiveInt.bind(null, 'limit')
+      "-l, --limit <lines>",
+      "Limit to N lines",
+      parsePositiveInt.bind(null, "limit")
     )
-    .option('--line-numbers', 'Prefix lines with numbers')
-    .option('--source', 'Include source metadata')
-    .option('--json', 'JSON output')
-    .option('--md', 'Markdown output')
+    .option("--line-numbers", "Prefix lines with numbers")
+    .option("--source", "Include source metadata")
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
     .action(async (ref: string, cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.get, format);
       const globals = getGlobals();
 
-      const { get, formatGet } = await import('./commands/get');
+      const { get, formatGet } = await import("./commands/get");
       const result = await get(ref, {
         configPath: globals.config,
         from: cmdOpts.from as number | undefined,
         limit: cmdOpts.limit as number | undefined,
         lineNumbers: Boolean(cmdOpts.lineNumbers),
         source: Boolean(cmdOpts.source),
-        json: format === 'json',
-        md: format === 'md',
+        json: format === "json",
+        md: format === "md",
       });
 
       if (!result.success) {
         throw new CliError(
-          result.isValidation ? 'VALIDATION' : 'RUNTIME',
+          result.isValidation ? "VALIDATION" : "RUNTIME",
           result.error
         );
       }
@@ -646,43 +647,43 @@ function wireRetrievalCommands(program: Command): void {
       process.stdout.write(
         `${formatGet(result, {
           lineNumbers: Boolean(cmdOpts.lineNumbers),
-          json: format === 'json',
-          md: format === 'md',
+          json: format === "json",
+          md: format === "md",
         })}\n`
       );
     });
 
   // multi-get - Retrieve multiple documents
   program
-    .command('multi-get <refs...>')
-    .description('Get multiple documents by URI or docid')
+    .command("multi-get <refs...>")
+    .description("Get multiple documents by URI or docid")
     .option(
-      '--max-bytes <n>',
-      'Max bytes per document',
-      parsePositiveInt.bind(null, 'max-bytes')
+      "--max-bytes <n>",
+      "Max bytes per document",
+      parsePositiveInt.bind(null, "max-bytes")
     )
-    .option('--line-numbers', 'Include line numbers')
-    .option('--json', 'JSON output')
-    .option('--files', 'File protocol output')
-    .option('--md', 'Markdown output')
+    .option("--line-numbers", "Include line numbers")
+    .option("--json", "JSON output")
+    .option("--files", "File protocol output")
+    .option("--md", "Markdown output")
     .action(async (refs: string[], cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.multiGet, format);
       const globals = getGlobals();
 
-      const { multiGet, formatMultiGet } = await import('./commands/multi-get');
+      const { multiGet, formatMultiGet } = await import("./commands/multi-get");
       const result = await multiGet(refs, {
         configPath: globals.config,
         maxBytes: cmdOpts.maxBytes as number | undefined,
         lineNumbers: Boolean(cmdOpts.lineNumbers),
-        json: format === 'json',
-        files: format === 'files',
-        md: format === 'md',
+        json: format === "json",
+        files: format === "files",
+        md: format === "md",
       });
 
       if (!result.success) {
         throw new CliError(
-          result.isValidation ? 'VALIDATION' : 'RUNTIME',
+          result.isValidation ? "VALIDATION" : "RUNTIME",
           result.error
         );
       }
@@ -690,58 +691,58 @@ function wireRetrievalCommands(program: Command): void {
       process.stdout.write(
         `${formatMultiGet(result, {
           lineNumbers: Boolean(cmdOpts.lineNumbers),
-          json: format === 'json',
-          files: format === 'files',
-          md: format === 'md',
+          json: format === "json",
+          files: format === "files",
+          md: format === "md",
         })}\n`
       );
     });
 
   // ls - List indexed documents
   program
-    .command('ls [scope]')
-    .description('List indexed documents')
+    .command("ls [scope]")
+    .description("List indexed documents")
     .option(
-      '-n, --limit <num>',
-      'Max results',
-      parsePositiveInt.bind(null, 'limit')
+      "-n, --limit <num>",
+      "Max results",
+      parsePositiveInt.bind(null, "limit")
     )
     .option(
-      '--offset <num>',
-      'Skip first N results',
-      parsePositiveInt.bind(null, 'offset')
+      "--offset <num>",
+      "Skip first N results",
+      parsePositiveInt.bind(null, "offset")
     )
-    .option('--json', 'JSON output')
-    .option('--files', 'File protocol output')
-    .option('--md', 'Markdown output')
+    .option("--json", "JSON output")
+    .option("--files", "File protocol output")
+    .option("--md", "Markdown output")
     .action(
       async (scope: string | undefined, cmdOpts: Record<string, unknown>) => {
         const format = getFormat(cmdOpts);
         assertFormatSupported(CMD.ls, format);
         const globals = getGlobals();
 
-        const { ls, formatLs } = await import('./commands/ls');
+        const { ls, formatLs } = await import("./commands/ls");
         const result = await ls(scope, {
           configPath: globals.config,
           limit: cmdOpts.limit as number | undefined,
           offset: cmdOpts.offset as number | undefined,
-          json: format === 'json',
-          files: format === 'files',
-          md: format === 'md',
+          json: format === "json",
+          files: format === "files",
+          md: format === "md",
         });
 
         if (!result.success) {
           throw new CliError(
-            result.isValidation ? 'VALIDATION' : 'RUNTIME',
+            result.isValidation ? "VALIDATION" : "RUNTIME",
             result.error
           );
         }
 
         process.stdout.write(
           `${formatLs(result, {
-            json: format === 'json',
-            files: format === 'files',
-            md: format === 'md',
+            json: format === "json",
+            files: format === "files",
+            md: format === "md",
           })}\n`
         );
       }
@@ -757,16 +758,16 @@ function wireMcpCommand(program: Command): void {
   // CRITICAL: helpOption(false) on server command prevents --help from writing
   // to stdout which would corrupt the JSON-RPC stream
   const mcpCmd = program
-    .command('mcp')
-    .description('MCP server and configuration');
+    .command("mcp")
+    .description("MCP server and configuration");
 
   // Default action: start MCP server
   mcpCmd
-    .command('serve', { isDefault: true })
-    .description('Start MCP server (stdio transport)')
+    .command("serve", { isDefault: true })
+    .description("Start MCP server (stdio transport)")
     .helpOption(false)
     .action(async () => {
-      const { mcpCommand } = await import('./commands/mcp.js');
+      const { mcpCommand } = await import("./commands/mcp.js");
       const globalOpts = program.opts();
       const globals = parseGlobalOptions(globalOpts);
       await mcpCommand(globals);
@@ -774,49 +775,49 @@ function wireMcpCommand(program: Command): void {
 
   // install - Install gno MCP server to client configs
   mcpCmd
-    .command('install')
-    .description('Install gno as MCP server in client configuration')
+    .command("install")
+    .description("Install gno as MCP server in client configuration")
     .option(
-      '-t, --target <target>',
-      'target client (claude-desktop, cursor, zed, windsurf, opencode, amp, lmstudio, librechat, claude-code, codex)',
-      'claude-desktop'
+      "-t, --target <target>",
+      "target client (claude-desktop, cursor, zed, windsurf, opencode, amp, lmstudio, librechat, claude-code, codex)",
+      "claude-desktop"
     )
     .option(
-      '-s, --scope <scope>',
-      'scope (user, project) - project only for claude-code/codex/cursor/opencode',
-      'user'
+      "-s, --scope <scope>",
+      "scope (user, project) - project only for claude-code/codex/cursor/opencode",
+      "user"
     )
-    .option('-f, --force', 'overwrite existing configuration')
-    .option('--dry-run', 'show what would be done without making changes')
-    .option('--json', 'JSON output')
+    .option("-f, --force", "overwrite existing configuration")
+    .option("--dry-run", "show what would be done without making changes")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const target = cmdOpts.target as string;
       const scope = cmdOpts.scope as string;
 
       // Import MCP_TARGETS for validation
-      const { MCP_TARGETS } = await import('./commands/mcp/paths.js');
+      const { MCP_TARGETS } = await import("./commands/mcp/paths.js");
 
       // Validate target
       if (!(MCP_TARGETS as string[]).includes(target)) {
         throw new CliError(
-          'VALIDATION',
-          `Invalid target: ${target}. Must be one of: ${MCP_TARGETS.join(', ')}.`
+          "VALIDATION",
+          `Invalid target: ${target}. Must be one of: ${MCP_TARGETS.join(", ")}.`
         );
       }
       // Validate scope
-      if (!['user', 'project'].includes(scope)) {
+      if (!["user", "project"].includes(scope)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid scope: ${scope}. Must be 'user' or 'project'.`
         );
       }
 
-      const { installMcp } = await import('./commands/mcp/install.js');
+      const { installMcp } = await import("./commands/mcp/install.js");
       await installMcp({
         target: target as NonNullable<
           Parameters<typeof installMcp>[0]
-        >['target'],
-        scope: scope as 'user' | 'project',
+        >["target"],
+        scope: scope as "user" | "project",
         force: Boolean(cmdOpts.force),
         dryRun: Boolean(cmdOpts.dryRun),
         // Pass undefined if not set, so global --json can take effect
@@ -826,43 +827,43 @@ function wireMcpCommand(program: Command): void {
 
   // uninstall - Remove gno MCP server from client configs
   mcpCmd
-    .command('uninstall')
-    .description('Remove gno MCP server from client configuration')
+    .command("uninstall")
+    .description("Remove gno MCP server from client configuration")
     .option(
-      '-t, --target <target>',
-      'target client (claude-desktop, cursor, zed, windsurf, opencode, amp, lmstudio, librechat, claude-code, codex)',
-      'claude-desktop'
+      "-t, --target <target>",
+      "target client (claude-desktop, cursor, zed, windsurf, opencode, amp, lmstudio, librechat, claude-code, codex)",
+      "claude-desktop"
     )
-    .option('-s, --scope <scope>', 'scope (user, project)', 'user')
-    .option('--json', 'JSON output')
+    .option("-s, --scope <scope>", "scope (user, project)", "user")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const target = cmdOpts.target as string;
       const scope = cmdOpts.scope as string;
 
       // Import MCP_TARGETS for validation
-      const { MCP_TARGETS } = await import('./commands/mcp/paths.js');
+      const { MCP_TARGETS } = await import("./commands/mcp/paths.js");
 
       // Validate target
       if (!(MCP_TARGETS as string[]).includes(target)) {
         throw new CliError(
-          'VALIDATION',
-          `Invalid target: ${target}. Must be one of: ${MCP_TARGETS.join(', ')}.`
+          "VALIDATION",
+          `Invalid target: ${target}. Must be one of: ${MCP_TARGETS.join(", ")}.`
         );
       }
       // Validate scope
-      if (!['user', 'project'].includes(scope)) {
+      if (!["user", "project"].includes(scope)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid scope: ${scope}. Must be 'user' or 'project'.`
         );
       }
 
-      const { uninstallMcp } = await import('./commands/mcp/uninstall.js');
+      const { uninstallMcp } = await import("./commands/mcp/uninstall.js");
       await uninstallMcp({
         target: target as NonNullable<
           Parameters<typeof uninstallMcp>[0]
-        >['target'],
-        scope: scope as 'user' | 'project',
+        >["target"],
+        scope: scope as "user" | "project",
         // Pass undefined if not set, so global --json can take effect
         json: cmdOpts.json === true ? true : undefined,
       });
@@ -870,60 +871,59 @@ function wireMcpCommand(program: Command): void {
 
   // status - Show MCP installation status
   mcpCmd
-    .command('status')
-    .description('Show MCP server installation status')
+    .command("status")
+    .description("Show MCP server installation status")
     .option(
-      '-t, --target <target>',
-      'filter by target (claude-desktop, cursor, zed, windsurf, opencode, amp, lmstudio, librechat, claude-code, codex, all)',
-      'all'
+      "-t, --target <target>",
+      "filter by target (claude-desktop, cursor, zed, windsurf, opencode, amp, lmstudio, librechat, claude-code, codex, all)",
+      "all"
     )
     .option(
-      '-s, --scope <scope>',
-      'filter by scope (user, project, all)',
-      'all'
+      "-s, --scope <scope>",
+      "filter by scope (user, project, all)",
+      "all"
     )
-    .option('--json', 'JSON output')
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const target = cmdOpts.target as string;
       const scope = cmdOpts.scope as string;
 
       // Import MCP_TARGETS for validation
-      const { MCP_TARGETS, TARGETS_WITH_PROJECT_SCOPE } = await import(
-        './commands/mcp/paths.js'
-      );
+      const { MCP_TARGETS, TARGETS_WITH_PROJECT_SCOPE } =
+        await import("./commands/mcp/paths.js");
 
       // Validate target
-      if (target !== 'all' && !(MCP_TARGETS as string[]).includes(target)) {
+      if (target !== "all" && !(MCP_TARGETS as string[]).includes(target)) {
         throw new CliError(
-          'VALIDATION',
-          `Invalid target: ${target}. Must be one of: ${MCP_TARGETS.join(', ')}, all.`
+          "VALIDATION",
+          `Invalid target: ${target}. Must be one of: ${MCP_TARGETS.join(", ")}, all.`
         );
       }
       // Validate scope
-      if (!['user', 'project', 'all'].includes(scope)) {
+      if (!["user", "project", "all"].includes(scope)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid scope: ${scope}. Must be 'user', 'project', or 'all'.`
         );
       }
       // Validate target/scope combination
       if (
-        target !== 'all' &&
-        scope === 'project' &&
+        target !== "all" &&
+        scope === "project" &&
         !(TARGETS_WITH_PROJECT_SCOPE as string[]).includes(target)
       ) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `${target} does not support project scope.`
         );
       }
 
-      const { statusMcp } = await import('./commands/mcp/status.js');
+      const { statusMcp } = await import("./commands/mcp/status.js");
       await statusMcp({
         target: target as NonNullable<
           Parameters<typeof statusMcp>[0]
-        >['target'],
-        scope: scope as 'user' | 'project' | 'all',
+        >["target"],
+        scope: scope as "user" | "project" | "all",
         // Pass undefined if not set, so global --json can take effect
         json: cmdOpts.json === true ? true : undefined,
       });
@@ -937,19 +937,19 @@ function wireMcpCommand(program: Command): void {
 function wireManagementCommands(program: Command): void {
   // collection subcommands
   const collectionCmd = program
-    .command('collection')
-    .description('Manage collections');
+    .command("collection")
+    .description("Manage collections");
 
   collectionCmd
-    .command('add <path>')
-    .description('Add a collection')
-    .requiredOption('-n, --name <name>', 'collection name')
-    .option('--pattern <glob>', 'file matching pattern')
-    .option('--include <exts>', 'extension allowlist (CSV)')
-    .option('--exclude <patterns>', 'exclude patterns (CSV)')
-    .option('--update <cmd>', 'shell command to run before indexing')
+    .command("add <path>")
+    .description("Add a collection")
+    .requiredOption("-n, --name <name>", "collection name")
+    .option("--pattern <glob>", "file matching pattern")
+    .option("--include <exts>", "extension allowlist (CSV)")
+    .option("--exclude <patterns>", "exclude patterns (CSV)")
+    .option("--update <cmd>", "shell command to run before indexing")
     .action(async (path: string, cmdOpts: Record<string, unknown>) => {
-      const { collectionAdd } = await import('./commands/collection');
+      const { collectionAdd } = await import("./commands/collection");
       await collectionAdd(path, {
         name: cmdOpts.name as string,
         pattern: cmdOpts.pattern as string | undefined,
@@ -960,136 +960,134 @@ function wireManagementCommands(program: Command): void {
     });
 
   collectionCmd
-    .command('list')
-    .description('List collections')
-    .option('--json', 'JSON output')
-    .option('--md', 'Markdown output')
+    .command("list")
+    .description("List collections")
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.collectionList, format);
 
-      const { collectionList } = await import('./commands/collection');
+      const { collectionList } = await import("./commands/collection");
       await collectionList({
-        json: format === 'json',
-        md: format === 'md',
+        json: format === "json",
+        md: format === "md",
       });
     });
 
   collectionCmd
-    .command('remove <name>')
-    .description('Remove a collection')
+    .command("remove <name>")
+    .description("Remove a collection")
     .action(async (name: string) => {
-      const { collectionRemove } = await import('./commands/collection');
+      const { collectionRemove } = await import("./commands/collection");
       await collectionRemove(name);
     });
 
   collectionCmd
-    .command('rename <old> <new>')
-    .description('Rename a collection')
+    .command("rename <old> <new>")
+    .description("Rename a collection")
     .action(async (oldName: string, newName: string) => {
-      const { collectionRename } = await import('./commands/collection');
+      const { collectionRename } = await import("./commands/collection");
       await collectionRename(oldName, newName);
     });
 
   // context subcommands
   const contextCmd = program
-    .command('context')
-    .description('Manage context items');
+    .command("context")
+    .description("Manage context items");
 
   contextCmd
-    .command('add <scope> <text>')
-    .description('Add context metadata for a scope')
+    .command("add <scope> <text>")
+    .description("Add context metadata for a scope")
     .action(async (scope: string, text: string) => {
-      const { contextAdd } = await import('./commands/context');
+      const { contextAdd } = await import("./commands/context");
       const exitCode = await contextAdd(scope, text);
       if (exitCode !== 0) {
-        throw new CliError('RUNTIME', 'Failed to add context');
+        throw new CliError("RUNTIME", "Failed to add context");
       }
     });
 
   contextCmd
-    .command('list')
-    .description('List context items')
-    .option('--json', 'JSON output')
-    .option('--md', 'Markdown output')
+    .command("list")
+    .description("List context items")
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.contextList, format);
 
-      const { contextList } = await import('./commands/context');
-      await contextList(format as 'terminal' | 'json' | 'md');
+      const { contextList } = await import("./commands/context");
+      await contextList(format as "terminal" | "json" | "md");
     });
 
   contextCmd
-    .command('check')
-    .description('Check context configuration')
-    .option('--json', 'JSON output')
-    .option('--md', 'Markdown output')
+    .command("check")
+    .description("Check context configuration")
+    .option("--json", "JSON output")
+    .option("--md", "Markdown output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.contextCheck, format);
 
-      const { contextCheck } = await import('./commands/context');
-      await contextCheck(format as 'terminal' | 'json' | 'md');
+      const { contextCheck } = await import("./commands/context");
+      await contextCheck(format as "terminal" | "json" | "md");
     });
 
   contextCmd
-    .command('rm <uri>')
-    .description('Remove context item')
+    .command("rm <uri>")
+    .description("Remove context item")
     .action(async (uri: string) => {
-      const { contextRm } = await import('./commands/context');
+      const { contextRm } = await import("./commands/context");
       await contextRm(uri);
     });
 
   // models subcommands
-  const modelsCmd = program.command('models').description('Manage LLM models');
+  const modelsCmd = program.command("models").description("Manage LLM models");
 
   modelsCmd
-    .command('list')
-    .description('List available models')
-    .option('--json', 'JSON output')
+    .command("list")
+    .description("List available models")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.modelsList, format);
 
-      const { modelsList, formatModelsList } = await import(
-        './commands/models'
-      );
-      const result = await modelsList({ json: format === 'json' });
+      const { modelsList, formatModelsList } =
+        await import("./commands/models");
+      const result = await modelsList({ json: format === "json" });
       process.stdout.write(
-        `${formatModelsList(result, { json: format === 'json' })}\n`
+        `${formatModelsList(result, { json: format === "json" })}\n`
       );
     });
 
   modelsCmd
-    .command('use')
-    .description('Switch active model preset')
-    .argument('<preset>', 'preset ID (slim, balanced, quality)')
+    .command("use")
+    .description("Switch active model preset")
+    .argument("<preset>", "preset ID (slim, balanced, quality)")
     .action(async (preset: string) => {
       const globals = getGlobals();
-      const { modelsUse, formatModelsUse } = await import(
-        './commands/models/use'
-      );
+      const { modelsUse, formatModelsUse } =
+        await import("./commands/models/use");
       const result = await modelsUse(preset, { configPath: globals.config });
       if (!result.success) {
-        throw new CliError('VALIDATION', result.error);
+        throw new CliError("VALIDATION", result.error);
       }
       process.stdout.write(`${formatModelsUse(result)}\n`);
     });
 
   modelsCmd
-    .command('pull')
-    .description('Download models')
-    .option('--all', 'download all configured models')
-    .option('--embed', 'download embedding model')
-    .option('--rerank', 'download reranker model')
-    .option('--gen', 'download generation model')
-    .option('--force', 'force re-download')
-    .option('--no-progress', 'disable download progress')
+    .command("pull")
+    .description("Download models")
+    .option("--all", "download all configured models")
+    .option("--embed", "download embedding model")
+    .option("--rerank", "download reranker model")
+    .option("--gen", "download generation model")
+    .option("--force", "force re-download")
+    .option("--no-progress", "disable download progress")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const globals = getGlobals();
       const { modelsPull, formatModelsPull, createProgressRenderer } =
-        await import('./commands/models');
+        await import("./commands/models");
 
       // Merge global quiet/json with local --no-progress
       const showProgress =
@@ -1111,45 +1109,43 @@ function wireManagementCommands(program: Command): void {
       // This allows partial success output before throwing
       process.stdout.write(`${formatModelsPull(result)}\n`);
       if (result.failed > 0) {
-        throw new CliError('RUNTIME', `${result.failed} model(s) failed`);
+        throw new CliError("RUNTIME", `${result.failed} model(s) failed`);
       }
     });
 
   modelsCmd
-    .command('clear')
-    .description('Clear model cache')
+    .command("clear")
+    .description("Clear model cache")
     .action(async () => {
       const globals = getGlobals();
-      const { modelsClear, formatModelsClear } = await import(
-        './commands/models'
-      );
+      const { modelsClear, formatModelsClear } =
+        await import("./commands/models");
       const result = await modelsClear({ yes: globals.yes });
       process.stdout.write(`${formatModelsClear(result)}\n`);
     });
 
   modelsCmd
-    .command('path')
-    .description('Show model cache path')
-    .option('--json', 'JSON output')
+    .command("path")
+    .description("Show model cache path")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
-      const { modelsPath, formatModelsPath } = await import(
-        './commands/models'
-      );
+      const { modelsPath, formatModelsPath } =
+        await import("./commands/models");
       const result = modelsPath();
       process.stdout.write(
-        `${formatModelsPath(result, { json: format === 'json' })}\n`
+        `${formatModelsPath(result, { json: format === "json" })}\n`
       );
     });
 
   // update - Sync files from disk
   program
-    .command('update')
-    .description('Sync files from disk into the index')
-    .option('--git-pull', 'run git pull in git repositories')
+    .command("update")
+    .description("Sync files from disk into the index")
+    .option("--git-pull", "run git pull in git repositories")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const globals = getGlobals();
-      const { update, formatUpdate } = await import('./commands/update');
+      const { update, formatUpdate } = await import("./commands/update");
       const opts = {
         gitPull: Boolean(cmdOpts.gitPull),
         verbose: globals.verbose,
@@ -1157,64 +1153,64 @@ function wireManagementCommands(program: Command): void {
       const result = await update(opts);
 
       if (!result.success) {
-        throw new CliError('RUNTIME', result.error ?? 'Update failed');
+        throw new CliError("RUNTIME", result.error ?? "Update failed");
       }
       process.stdout.write(`${formatUpdate(result, opts)}\n`);
     });
 
   // embed - Generate embeddings
   program
-    .command('embed')
-    .description('Generate embeddings for indexed documents')
-    .option('--model <uri>', 'embedding model URI')
-    .option('--batch-size <num>', 'batch size', '32')
-    .option('--force', 'regenerate all embeddings')
-    .option('--dry-run', 'show what would be done')
-    .option('--json', 'JSON output')
+    .command("embed")
+    .description("Generate embeddings for indexed documents")
+    .option("--model <uri>", "embedding model URI")
+    .option("--batch-size <num>", "batch size", "32")
+    .option("--force", "regenerate all embeddings")
+    .option("--dry-run", "show what would be done")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const globals = getGlobals();
       const format = getFormat(cmdOpts);
 
-      const { embed, formatEmbed } = await import('./commands/embed');
+      const { embed, formatEmbed } = await import("./commands/embed");
       const opts = {
         model: cmdOpts.model as string | undefined,
-        batchSize: parsePositiveInt('batch-size', cmdOpts.batchSize),
+        batchSize: parsePositiveInt("batch-size", cmdOpts.batchSize),
         force: Boolean(cmdOpts.force),
         dryRun: Boolean(cmdOpts.dryRun),
         yes: globals.yes,
-        json: format === 'json',
+        json: format === "json",
       };
       const result = await embed(opts);
 
       if (!result.success) {
-        throw new CliError('RUNTIME', result.error ?? 'Embed failed');
+        throw new CliError("RUNTIME", result.error ?? "Embed failed");
       }
       process.stdout.write(`${formatEmbed(result, opts)}\n`);
     });
 
   // cleanup - Clean stale data
   program
-    .command('cleanup')
-    .description('Clean orphaned data from index')
+    .command("cleanup")
+    .description("Clean orphaned data from index")
     .action(async () => {
-      const { cleanup, formatCleanup } = await import('./commands/cleanup');
+      const { cleanup, formatCleanup } = await import("./commands/cleanup");
       const result = await cleanup();
 
       if (!result.success) {
-        throw new CliError('RUNTIME', result.error ?? 'Cleanup failed');
+        throw new CliError("RUNTIME", result.error ?? "Cleanup failed");
       }
       process.stdout.write(`${formatCleanup(result)}\n`);
     });
 
   // reset - Reset GNO to fresh state
   program
-    .command('reset')
-    .description('Delete all GNO data and start fresh')
-    .option('--confirm', 'confirm destructive operation')
-    .option('--keep-config', 'preserve config file')
-    .option('--keep-cache', 'preserve model cache')
+    .command("reset")
+    .description("Delete all GNO data and start fresh")
+    .option("--confirm", "confirm destructive operation")
+    .option("--keep-config", "preserve config file")
+    .option("--keep-cache", "preserve model cache")
     .action(async (cmdOpts: Record<string, unknown>) => {
-      const { reset, formatReset } = await import('./commands/reset');
+      const { reset, formatReset } = await import("./commands/reset");
       const globals = getGlobals();
       const result = await reset({
         // Accept either --confirm or global --yes
@@ -1232,100 +1228,100 @@ function wireManagementCommands(program: Command): void {
 
 function wireSkillCommands(program: Command): void {
   const skillCmd = program
-    .command('skill')
-    .description('Manage GNO agent skill');
+    .command("skill")
+    .description("Manage GNO agent skill");
 
   skillCmd
-    .command('install')
-    .description('Install GNO skill to Claude Code or Codex')
+    .command("install")
+    .description("Install GNO skill to Claude Code or Codex")
     .option(
-      '-s, --scope <scope>',
-      'installation scope (project, user)',
-      'project'
+      "-s, --scope <scope>",
+      "installation scope (project, user)",
+      "project"
     )
     .option(
-      '-t, --target <target>',
-      'target agent (claude, codex, all)',
-      'claude'
+      "-t, --target <target>",
+      "target agent (claude, codex, all)",
+      "claude"
     )
-    .option('-f, --force', 'overwrite existing installation')
-    .option('--json', 'JSON output')
+    .option("-f, --force", "overwrite existing installation")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const scope = cmdOpts.scope as string;
       const target = cmdOpts.target as string;
 
       // Validate scope
-      if (!['project', 'user'].includes(scope)) {
+      if (!["project", "user"].includes(scope)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid scope: ${scope}. Must be 'project' or 'user'.`
         );
       }
       // Validate target
-      if (!['claude', 'codex', 'all'].includes(target)) {
+      if (!["claude", "codex", "all"].includes(target)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid target: ${target}. Must be 'claude', 'codex', or 'all'.`
         );
       }
 
-      const { installSkill } = await import('./commands/skill/install.js');
+      const { installSkill } = await import("./commands/skill/install.js");
       await installSkill({
-        scope: scope as 'project' | 'user',
-        target: target as 'claude' | 'codex' | 'all',
+        scope: scope as "project" | "user",
+        target: target as "claude" | "codex" | "all",
         force: Boolean(cmdOpts.force),
         json: Boolean(cmdOpts.json),
       });
     });
 
   skillCmd
-    .command('uninstall')
-    .description('Uninstall GNO skill')
+    .command("uninstall")
+    .description("Uninstall GNO skill")
     .option(
-      '-s, --scope <scope>',
-      'installation scope (project, user)',
-      'project'
+      "-s, --scope <scope>",
+      "installation scope (project, user)",
+      "project"
     )
     .option(
-      '-t, --target <target>',
-      'target agent (claude, codex, all)',
-      'claude'
+      "-t, --target <target>",
+      "target agent (claude, codex, all)",
+      "claude"
     )
-    .option('--json', 'JSON output')
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const scope = cmdOpts.scope as string;
       const target = cmdOpts.target as string;
 
       // Validate scope
-      if (!['project', 'user'].includes(scope)) {
+      if (!["project", "user"].includes(scope)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid scope: ${scope}. Must be 'project' or 'user'.`
         );
       }
       // Validate target
-      if (!['claude', 'codex', 'all'].includes(target)) {
+      if (!["claude", "codex", "all"].includes(target)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid target: ${target}. Must be 'claude', 'codex', or 'all'.`
         );
       }
 
-      const { uninstallSkill } = await import('./commands/skill/uninstall.js');
+      const { uninstallSkill } = await import("./commands/skill/uninstall.js");
       await uninstallSkill({
-        scope: scope as 'project' | 'user',
-        target: target as 'claude' | 'codex' | 'all',
+        scope: scope as "project" | "user",
+        target: target as "claude" | "codex" | "all",
         json: Boolean(cmdOpts.json),
       });
     });
 
   skillCmd
-    .command('show')
-    .description('Preview skill files without installing')
-    .option('--file <name>', 'specific file to show')
-    .option('--all', 'show all skill files')
+    .command("show")
+    .description("Preview skill files without installing")
+    .option("--file <name>", "specific file to show")
+    .option("--all", "show all skill files")
     .action(async (cmdOpts: Record<string, unknown>) => {
-      const { showSkill } = await import('./commands/skill/show.js');
+      const { showSkill } = await import("./commands/skill/show.js");
       await showSkill({
         file: cmdOpts.file as string | undefined,
         all: Boolean(cmdOpts.all),
@@ -1333,42 +1329,42 @@ function wireSkillCommands(program: Command): void {
     });
 
   skillCmd
-    .command('paths')
-    .description('Show resolved skill installation paths')
+    .command("paths")
+    .description("Show resolved skill installation paths")
     .option(
-      '-s, --scope <scope>',
-      'filter by scope (project, user, all)',
-      'all'
+      "-s, --scope <scope>",
+      "filter by scope (project, user, all)",
+      "all"
     )
     .option(
-      '-t, --target <target>',
-      'filter by target (claude, codex, all)',
-      'all'
+      "-t, --target <target>",
+      "filter by target (claude, codex, all)",
+      "all"
     )
-    .option('--json', 'JSON output')
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const scope = cmdOpts.scope as string;
       const target = cmdOpts.target as string;
 
       // Validate scope
-      if (!['project', 'user', 'all'].includes(scope)) {
+      if (!["project", "user", "all"].includes(scope)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid scope: ${scope}. Must be 'project', 'user', or 'all'.`
         );
       }
       // Validate target
-      if (!['claude', 'codex', 'all'].includes(target)) {
+      if (!["claude", "codex", "all"].includes(target)) {
         throw new CliError(
-          'VALIDATION',
+          "VALIDATION",
           `Invalid target: ${target}. Must be 'claude', 'codex', or 'all'.`
         );
       }
 
-      const { showPaths } = await import('./commands/skill/paths-cmd.js');
+      const { showPaths } = await import("./commands/skill/paths-cmd.js");
       await showPaths({
-        scope: scope as 'project' | 'user' | 'all',
-        target: target as 'claude' | 'codex' | 'all',
+        scope: scope as "project" | "user" | "all",
+        target: target as "claude" | "codex" | "all",
         json: Boolean(cmdOpts.json),
       });
     });
@@ -1380,14 +1376,14 @@ function wireSkillCommands(program: Command): void {
 
 function wireServeCommand(program: Command): void {
   program
-    .command('serve')
-    .description('Start web UI server')
-    .option('-p, --port <num>', 'port to listen on', '3000')
+    .command("serve")
+    .description("Start web UI server")
+    .option("-p, --port <num>", "port to listen on", "3000")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const globals = getGlobals();
-      const port = parsePositiveInt('port', cmdOpts.port);
+      const port = parsePositiveInt("port", cmdOpts.port);
 
-      const { serve } = await import('./commands/serve.js');
+      const { serve } = await import("./commands/serve.js");
       const result = await serve({
         port,
         configPath: globals.config,
@@ -1395,7 +1391,7 @@ function wireServeCommand(program: Command): void {
       });
 
       if (!result.success) {
-        throw new CliError('RUNTIME', result.error ?? 'Server failed to start');
+        throw new CliError("RUNTIME", result.error ?? "Server failed to start");
       }
       // Server runs until SIGINT/SIGTERM - no output needed here
     });