aontu 0.55.0 → 0.57.0

package/src/cli.ts

@@ -12,7 +12,7 @@
 import { evalFailure } from './query'
 // __importStar downlevel helper, whose branches no supported Node takes.
 import {
-  mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync,
+  existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync,
 } from 'node:fs'
 import { basename, dirname, join, resolve } from 'node:path'
 import { tmpdir } from 'node:os'
@@ -25,6 +25,8 @@ import {
   get, why, patch, agentsMd,
 } from './aontu'
 import { sarifReport } from './report-sarif'
+import { main as lspMain } from './lsp-server'
+import { main as mcpMain } from './mcp-server'
 import { jsonSchema } from './jsonschema'
 import { modTidy, modVerify, modVendor, modManifest } from './mod-tool'
 import type {
@@ -48,6 +50,9 @@ import type {
 import type { QueryView } from './query'
 import type { WhyRecord } from './provenance'
 import { agentsMdSplice } from './agentsmd'
+import { format, unifiedDiff } from './format'
+import { includeOpts } from './utility'
+import type { IncludeOptions } from './utility'
 
 
 type Mode = 'json' | 'canon'
@@ -69,6 +74,9 @@ const HELP = `Usage: aontu [options] [file]
        aontu why <path> [options] <file>
        aontu set <path>=<value>... --entry <file> --overlay <file>
        aontu agentsmd [--write <AGENTS.md>] <file>
+       aontu fmt [-w|-l|--check|-d|--lint] <file>...
+       aontu lsp
+       aontu mcp [--root <dir>]
 
 Evaluate an Aontu source file and print the result as JSON.
 With no file on an interactive terminal, start a REPL.
@@ -91,6 +99,10 @@ Options:
                   Every verb takes it too, and a bare root means the
                   document's own directory
   --include-root <dir>  Shorthand for --trust root:<dir>
+  --text-ext <e>  Read these extensions as text too, comma-separated
+                  and without dots (md,sql). .txt needs no flag; a
+                  named format keeps its meaning, and .js stays
+                  refused. Every verb takes it
 
 Mod options:
   --format <f>    text (default) or json
@@ -98,10 +110,10 @@ Mod options:
 
 Mod subcommands:
   tidy      Resolve the module closure by minimum version selection and
-            rewrite mod-lock.aon in canonical form
-  verify    Check every locked module still means what mod-lock.aon
+            rewrite aontu_meta/mod-lock.aon in canonical form
+  verify    Check every locked module still means what the lockfile
             pins, and change nothing (the CI gate; tidy rewrites)
-  vendor    Materialise the locked closure into aon_vendor/
+  vendor    Materialise the locked closure into aontu_meta/vendor/
   manifest  Print the OCI artifact a publish would push, gated on the
             breaking check against --against
 
@@ -182,8 +194,8 @@ Why options:
 Why exit codes mirror get's: 0 explained, 1 the path names nothing,
 2 usage, 4 the document does not stand up on its own.
 
-View kinds: tree, matrix, graph, layer, sets, layers, ladder, poset
-(the poset takes several files). The figure goes to stdout, the loss
+View kinds: doc, lattice, tree, matrix, graph, layer, sets, layers,
+ladder, poset (the poset takes several files). The figure goes to stdout, the loss
 report to stderr. With --views it draws every figure a document
 declares as data, from one evaluation: each declaration names its own
 kind and out file, nothing is written unless every figure rendered,
@@ -191,13 +203,13 @@ and --check gates the committed set.
 
 View options:
   --as <profile>    text | mermaid | dot | er | svg, per kind: doc,
-                    tree, matrix, sets and layers draw text (default)
-                    or svg; graph draws mermaid (default), dot or er;
-                    layer draws text (default), mermaid or svg; ladder
-                    and poset draw mermaid (default) or dot
+                    lattice, tree, matrix, sets and layers draw text
+                    (default) or svg; graph draws mermaid (default),
+                    dot or er; layer draws text (default), mermaid or
+                    svg; ladder and poset draw mermaid (default) or dot
   --at <path>       Restrict the figure to nodes under this path; the
-                    subtree doc draws; the path the ladder draws;
-                    where the poset compares
+                    subtree doc draws; the subtree the lattice counts;
+                    the path the ladder draws; where the poset compares
   --views <path>    Draw every figure the document declares at this
                     path, one evaluation, all or nothing; each
                     declaration names its own kind and out file
@@ -276,6 +288,32 @@ Agentsmd options:
 Agentsmd exit codes: 0 generated, 2 usage, 4 the document does not
 stand up on its own.
 
+Fmt options:
+  -w, --write     Rewrite each file in place, when its form would change
+  -l, --list      Print the name of each file whose form would change
+  --check         Like --list, and exit 1 when any would: the CI gate
+  -d, --diff      Print a unified diff for each file whose form would
+                  change
+  --lint          Report the style findings, key case and repeated
+                  shapes, on standard error, and print nothing else
+  --strict        With --lint, and exit 1 when there is a finding
+
+The fmt verb prints one document in the agreed form; with no file it
+reads standard input. Several files need one of the options above.
+
+Fmt exit codes: 0 formatted or clean, 1 a --check file would change or
+a --strict finding, 2 usage, 4 a document does not parse.
+
+The lsp verb runs the language server over standard input and output
+(LSP: JSON-RPC with Content-Length framing) until the client exits;
+editors launch it with no arguments. The standalone aontu-lsp binary
+runs the same server.
+
+The mcp verb runs the Model Context Protocol server over standard
+input and output (newline-delimited JSON-RPC), confined below --root
+when one is given. It is part of the npm build, as the standalone
+aontu-mcp binary is.
+
 REPL commands:
   :help           Show REPL help
   :load <file>    Evaluate a document and hold it for the commands below
@@ -333,11 +371,18 @@ function evalSource(
 // entry root or goes through package resolution prints a one-line
 // stderr warning naming the flag a future default will require
 // (phase 6, the staged flip).
-type TrustArg =
+type TrustArg = (
   | { kind: 'system-warn' }
   | { kind: 'system' }
   | { kind: 'none' }
   | { kind: 'root', dir?: string }
+  // EXTENSIONS READ AS TEXT ride with the capability rather than
+  // beside it: both answer "what may an include read", both are
+  // stripped by takeTrust before a verb parses its own tail, and a
+  // verb that threads one and not the other is the G5 defect again --
+  // `aontu vet` running under a flag the bare command honoured and it
+  // did not.
+) & { textExt: string[] }
 
 
 // The one-line warning of the staged default flip. Once per (kind,
@@ -366,15 +411,16 @@ function makeTrustWarn(): (kind: 'escape' | 'pkg', path: string) => void {
 // entryRoot (the entry file's directory, or the working directory for
 // stdin/REPL).
 function trustOpts(trust: TrustArg, entryRoot: string): any {
+  const text = 0 === trust.textExt.length ? {} : { textExt: trust.textExt }
   switch (trust.kind) {
     case 'none':
-      return { trust: { include: 'none' } }
+      return { ...text, trust: { include: 'none' } }
     case 'root':
-      return { trust: { include: { root: trust.dir ?? entryRoot } } }
+      return { ...text, trust: { include: { root: trust.dir ?? entryRoot } } }
     case 'system':
-      return {}
+      return { ...text }
     default:  // system-warn: today's default plus the warning window
-      return { trustWarn: makeTrustWarn(), trustWarnRoot: entryRoot }
+      return { ...text, trustWarn: makeTrustWarn(), trustWarnRoot: entryRoot }
   }
 }
 
@@ -392,7 +438,8 @@ function trustOpts(trust: TrustArg, entryRoot: string): any {
 function takeTrust(argv: string[]):
   { argv: string[], trust: TrustArg } | undefined {
   const rest: string[] = []
-  let trust: TrustArg = { kind: 'system-warn' }
+  let trust: TrustArg = { kind: 'system-warn', textExt: [] }
+  let textExt: string[] = []
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i]
     if ('--trust' === arg) {
@@ -410,21 +457,47 @@ function takeTrust(argv: string[]):
         process.stderr.write('aontu: --include-root needs a directory\n')
         return undefined
       }
-      trust = { kind: 'root', dir }
+      trust = { kind: 'root', dir, textExt }
+    }
+    else if ('--text-ext' === arg) {
+      const list = null == argv[i + 1] ? undefined : parseTextExt(argv[++i])
+      if (null == list) {
+        process.stderr.write(
+          'aontu: --text-ext needs extensions, without dots' +
+          ' (--text-ext md,sql)\n')
+        return undefined
+      }
+      textExt = [...textExt, ...list]
     }
     else {
       rest.push(arg)
     }
   }
-  return { argv: rest, trust }
+  return { argv: rest, trust: { ...trust, textExt } }
+}
+
+
+// `md,sql` or `.md,.sql` -- the dot is accepted and dropped, because a
+// reader who has just written `@"notes.txt"` reaches for one. An empty
+// element, or anything that is not an extension, is a usage error
+// rather than a silently ignored word: a flag that quietly does
+// nothing is how a document ends up refused with no reason visible.
+function parseTextExt(arg: string): string[] | undefined {
+  const out: string[] = []
+  for (const raw of arg.split(',')) {
+    const ext = raw.trim().replace(/^\./, '').toLowerCase()
+    if ('' === ext || !/^[a-z0-9]+$/.test(ext)) {
+      return undefined
+    }
+    out.push(ext)
+  }
+  return out
 }
 
 
 // The evaluator options a REPL session's capability means.
 function replTrust(state: ReplState, entryRoot: string): any {
-  const capability = verbTrust(
-    state.trust ?? { kind: 'system-warn' }, entryRoot)
-  return null == capability ? {} : { trust: capability }
+  return verbOpts(state.trust ?? { kind: 'system-warn', textExt: [] }, entryRoot)
 }
 
 
@@ -444,6 +517,20 @@ function verbTrust(trust: TrustArg, entryRoot: string): any {
 }
 
 
+// THE INCLUDE OPTIONS A VERB RUNS UNDER, spread into its engine call:
+// the capability above, and the extensions `--text-ext` widened. Both
+// are absent when unset rather than present-and-undefined, so a verb's
+// options bag is byte-identical to what it was before either flag
+// existed and no engine sees a key it has to ignore.
+function verbOpts(trust: TrustArg, entryRoot: string): any {
+  const include = verbTrust(trust, entryRoot)
+  return {
+    ...(undefined === include ? {} : { trust: include }),
+    ...(0 === trust.textExt.length ? {} : { textExt: trust.textExt }),
+  }
+}
+
+
 // The directory a bare `--trust root` confines to for a verb: the
 // primary document's own, matching the bare command's entry root.
 function entryRootOf(file: string | undefined): string {
@@ -607,7 +694,7 @@ export function replCommand(
       if (':why' === cmd) {
         const report = why(src, path, {
           path: state.name,
-          trust: verbTrust(state.trust ?? { kind: 'system-warn' },
+          ...verbOpts(state.trust ?? { kind: 'system-warn', textExt: [] },
             entryRootOf(state.name)),
         })
         return report.ok
@@ -618,7 +705,7 @@ export function replCommand(
         ? 'keys' : 'canon' === state.mode ? 'canon' : 'json'
       const report = get(src, path, {
         view, path: state.name,
-        trust: verbTrust(state.trust ?? { kind: 'system-warn' },
+        ...verbOpts(state.trust ?? { kind: 'system-warn', textExt: [] },
           entryRootOf(state.name)),
       })
       return report.ok
@@ -901,7 +988,7 @@ function vetOnce(args: VetArgs, trust: TrustArg): number {
 
   for (const source of sources) {
     const report = vet(schemaSrc, source.src, {
-      trust: verbTrust(trust, entryRootOf(args.schema)),
+      ...verbOpts(trust, entryRootOf(args.schema)),
       at: args.at,
       closed: args.closed,
       partial: args.partial,
@@ -1193,7 +1280,7 @@ function runSubsume(argv: string[]): number {
   }
 
   const report = subsume(generalSrc, specificSrc, {
-    trust: verbTrust(trust, entryRootOf(args.general)),
+    ...verbOpts(trust, entryRootOf(args.general)),
     profile: args.profile,
     at: args.at,
     generalUrl: args.general,
@@ -1417,15 +1504,18 @@ function oldVersion(spec: string, file: string): OldVersion | undefined {
 // a disjunction whose default is the declared mode. Undefined when the
 // key is absent or does not spell a mode.
 function policyCompat(
-  newSrc: string, path: string, trust: any): BreakingMode | undefined {
+  newSrc: string, path: string, include: IncludeOptions
+): BreakingMode | undefined {
   const aontu = new Aontu()
   const ctx = aontu.ctx({ collect: true })
   // The declaration is read by EVALUATING the document, so this leg
-  // runs the include resolver too and has to run it under the verb's
-  // capability -- a `breaking --trust none` that read its own mode
-  // through an unconfined resolver would confine the comparison and
-  // not the question (use-cases/REVIEW.md finding G).
-  const v: any = aontu.unify(newSrc, { path, ...(null == trust ? {} : { trust }) }, ctx)
+  // runs the include resolver too and has to run it under BOTH of the
+  // verb's include options -- a `breaking --trust none` that read its
+  // own mode through an unconfined resolver would confine the
+  // comparison and not the question (use-cases/REVIEW.md finding G),
+  // and one that took the capability alone read no mode at all when
+  // the declaration arrived through a `--text-ext` include.
+  const v: any = aontu.unify(newSrc, { path, ...includeOpts(include) }, ctx)
   if (0 < ctx.err.length || true === v?.isNil) {
     return undefined
   }
@@ -1528,7 +1618,8 @@ function runBreaking(argv: string[]): number {
   // stay valid).
   const mode: BreakingMode =
     args.mode ??
-    policyCompat(newSrc, args.file, verbTrust(trust, entryRootOf(args.file))) ??
+    policyCompat(newSrc, args.file,
+      verbOpts(trust, entryRootOf(args.file))) ??
     'backward'
 
   if ('none' === mode) {
@@ -1578,7 +1669,7 @@ function runBreaking(argv: string[]): number {
 
     for (const check of checks) {
       const report = subsume(check.general[0], check.specific[0], {
-        trust: verbTrust(trust, entryRootOf(args.file)),
+        ...verbOpts(trust, entryRootOf(args.file)),
         at: args.at,
         generalUrl: check.general[1],
         specificUrl: check.specific[1],
@@ -1724,7 +1815,7 @@ function runTrim(argv: string[]): number {
   }
 
   const report = trimCheck(src, {
-    path: files[0], trust: verbTrust(trust, entryRootOf(files[0])),
+    path: files[0], ...verbOpts(trust, entryRootOf(files[0])),
   })
   const text = 'json' === format
     ? renderTrimJson(report)
@@ -1788,8 +1879,8 @@ const VIEW_HELP =
   'aontu view <kind> [options] <file>... (try --help)'
 
 const VIEW_KINDS: ViewKind[] =
-  ['doc', 'tree', 'matrix', 'graph', 'layer', 'sets', 'layers', 'ladder',
-    'poset']
+  ['doc', 'lattice', 'tree', 'matrix', 'graph', 'layer', 'sets', 'layers',
+    'ladder', 'poset']
 
 const VIEW_PROFILES: ViewProfile[] = ['text', 'mermaid', 'dot', 'er', 'svg']
 
@@ -1920,6 +2011,16 @@ function runMod(argv: string[]): number {
     return 2
   }
 
+  // THE OLD LAYOUT IS NAMED, NOT READ. The lockfile and the vendored
+  // closure moved under aontu_meta/; a project that still carries them
+  // at its root would otherwise look untouched by any of these verbs,
+  // which is the one silence worth breaking.
+  if (existsSync(join(dir, 'aon_vendor')) || existsSync(join(dir, 'mod-lock.aon'))) {
+    process.stderr.write(
+      'aontu: aon_vendor/ and mod-lock.aon now live under aontu_meta/: ' +
+      'move them, or run aontu mod tidy and aontu mod vendor\n')
+  }
+
   // `--against` gates a manifest and means nothing to the other two;
   // accepting it there would say it had been honoured.
   if (null != against && 'manifest' !== sub) {
@@ -2110,7 +2211,7 @@ function runRelations(argv: string[]): number {
   }
 
   const report = relationCheck(src, {
-    path: files[0], trust: verbTrust(trust, entryRootOf(files[0])),
+    path: files[0], ...verbOpts(trust, entryRootOf(files[0])),
   })
   const text = 'json' === format
     ? renderRelationsJson(report)
@@ -2178,7 +2279,7 @@ function runReaches(argv: string[]): number {
 
   const report = reachCheck(src, rest[0], rest[1], {
     path: rest[2], relation,
-    trust: verbTrust(trust, entryRootOf(rest[2])),
+    ...verbOpts(trust, entryRootOf(rest[2])),
   })
   const text = 'json' === format
     ? renderReachesJson(report)
@@ -2424,7 +2525,7 @@ function runView(argv: string[]): number {
     kind,
     path: files[0],
     roots,
-    trust: verbTrust(trust, entryRootOf(files[0])),
+    ...verbOpts(trust, entryRootOf(files[0])),
     docs: files.slice(1).map((path, i) => ({ src: srcs[i + 1], path })),
   })
 
@@ -2503,7 +2604,7 @@ function runViewSet(
   }
 
   const report = viewSet(src, {
-    ...opts, path: file, trust: verbTrust(trust, entryRootOf(file)),
+    ...opts, path: file, ...verbOpts(trust, entryRootOf(file)),
   })
 
   if ('json' === how.format) {
@@ -2726,7 +2827,7 @@ function runJsonSchema(argv: string[]): number {
   }
 
   const report = jsonSchema(src, {
-    at, path: files[0], trust: verbTrust(trust, entryRootOf(files[0])),
+    at, path: files[0], ...verbOpts(trust, entryRootOf(files[0])),
   })
 
   if ('json' === format) {
@@ -2819,9 +2920,7 @@ function runHash(argv: string[]): number {
 
   // The file's own directory is the include base, as every verb
   // resolves a named file (vet's aontuForPath rule).
-  const capability = verbTrust(trust, entryRootOf(files[0]))
-  const aontu = new Aontu(
-    null == capability ? undefined : { trust: capability })
+  const aontu = new Aontu(verbOpts(trust, entryRootOf(files[0])))
   const ctx = aontu.ctx({ collect: true })
   const v: any = aontu.unify(src, { path: files[0] }, ctx)
   if (0 < ctx.err.length || true === v?.isNil) {
@@ -2937,7 +3036,7 @@ function runGet(argv: string[]): number {
   }
 
   const report = get(src, path, {
-    view, depth, path: file, trust: verbTrust(trust, entryRootOf(file)),
+    view, depth, path: file, ...verbOpts(trust, entryRootOf(file)),
   })
   if ('json' === format) {
     process.stdout.write(exactJSON({
@@ -3021,7 +3120,7 @@ function runWhy(argv: string[]): number {
   }
 
   const report = why(src, path, {
-    path: file, trust: verbTrust(trust, entryRootOf(file)),
+    path: file, ...verbOpts(trust, entryRootOf(file)),
   })
   if ('json' === format) {
     process.stdout.write(exactJSON({
@@ -3156,7 +3255,7 @@ function runSet(argv: string[]): number {
   }
 
   const report = patch(entrySrc, overlaySrc, assignments, {
-    trust: verbTrust(trust, entryRootOf(entry)),
+    ...verbOpts(trust, entryRootOf(entry)),
     entryPath: entry,
     overlayPath: overlayFile,
     inPlace,
@@ -3291,7 +3390,7 @@ function runAgentsMd(argv: string[]): number {
 
   const report = agentsMd(src, {
     name: files[0], path: files[0],
-    trust: verbTrust(trust, entryRootOf(files[0])),
+    ...verbOpts(trust, entryRootOf(files[0])),
   })
   if (!report.ok) {
     process.stderr.write(
@@ -3343,6 +3442,188 @@ function runAgentsMd(argv: string[]): number {
 // on the parity-probe discipline in AGENTS.md, which derives expected
 // spec values by piping BOTH CLIs and comparing. A truncated pipe there
 // reads as a port divergence.
+// ---------------------------------------------------------------------
+// The source formatter (docs/design/FMT.0.md): one agreed form, in the
+// tradition of gofmt. The verb prints, lists, checks, diffs or rewrites;
+// the form itself is the library's (ts/src/format.ts), and the two
+// ports agree on it row by row in test/spec/fmt.tsv.
+
+const FMT_HELP = 'aontu fmt [-w|-l|--check|-d|--lint] <file>... (try --help)'
+
+type FmtFlags = {
+  write: boolean, list: boolean, check: boolean, diff: boolean, lint: boolean, strict: boolean,
+}
+
+function runFmt(argv: string[]): number | Promise<number> {
+  const files: string[] = []
+  const flags: FmtFlags = {
+    write: false, list: false, check: false, diff: false, lint: false, strict: false,
+  }
+
+  for (const arg of argv) {
+    if ('-h' === arg || '--help' === arg) {
+      process.stdout.write(HELP)
+      return 0
+    }
+    if ('-w' === arg || '--write' === arg) {
+      flags.write = true
+    }
+    else if ('-l' === arg || '--list' === arg) {
+      flags.list = true
+    }
+    else if ('--check' === arg) {
+      flags.check = true
+    }
+    else if ('-d' === arg || '--diff' === arg) {
+      flags.diff = true
+    }
+    else if ('--lint' === arg) {
+      flags.lint = true
+    }
+    else if ('--strict' === arg) {
+      flags.lint = true
+      flags.strict = true
+    }
+    else if (arg.startsWith('-')) {
+      process.stderr.write(`aontu: unknown fmt option ${arg} (try --help)\n`)
+      return 2
+    }
+    else {
+      files.push(arg)
+    }
+  }
+
+  if (0 === files.length) {
+    // Standard input: formatted onto standard output, or listed,
+    // checked and diffed under the name <stdin>. It cannot be written
+    // back.
+    if (flags.write) {
+      process.stderr.write(`aontu: --write needs a file\n${FMT_HELP}\n`)
+      return 2
+    }
+    return new Promise((resolve) => {
+      let src = ''
+      process.stdin.setEncoding('utf8')
+      process.stdin.on('data', (d) => (src += d))
+      process.stdin.on('end', () => resolve(fmtOne('<stdin>', src, flags)))
+    })
+  }
+
+  // Several files onto standard output would be one stream nobody can
+  // split again (the note's X-6): the verb refuses unless an option
+  // says what to do with each.
+  if (1 < files.length && !fmtQuiet(flags)) {
+    process.stderr.write(
+      `aontu: fmt prints one file; with ${files.length}, say --write, ` +
+      `--list, --check, --diff or --lint\n${FMT_HELP}\n`)
+    return 2
+  }
+
+  let worst = 0
+  for (const file of files) {
+    let src: string
+    try {
+      src = readFileSync(file, 'utf8')
+    }
+    catch (err: any) {
+      process.stderr.write(`aontu: cannot read ${err.path}: ${err.message}\n`)
+      return 2
+    }
+    worst = Math.max(worst, fmtOne(file, src, flags))
+  }
+  return worst
+}
+
+// An option that says what to do with a file, in place of printing
+// it: what to do when its form would change, or the lint.
+function fmtQuiet(flags: FmtFlags): boolean {
+  return flags.write || flags.list || flags.check || flags.diff || flags.lint
+}
+
+// One document: 0 printed, clean or done; 1 a --check that would
+// change, or a --strict finding; 2 a file that cannot be written; 4 a
+// document that does not format, with the finding that says why. The
+// style findings go to standard error, one line each, in the shape
+// every linter prints: `file:line:col: rule: message`.
+function fmtOne(name: string, src: string, flags: FmtFlags): number {
+  const report = format(src, { path: name, lint: flags.lint })
+  if ('error' === report.verdict) {
+    process.stderr.write(`aontu: ${name} was not formatted\n` +
+      report.errors.map(renderFinding).join('\n') + '\n')
+    return 4
+  }
+  for (const f of report.findings) {
+    process.stderr.write(`${name}:${f.line}:${f.col}: ${f.rule}: ${f.message}\n`)
+  }
+  const strict = flags.strict && 0 < report.findings.length ? 1 : 0
+  if (!fmtQuiet(flags)) {
+    process.stdout.write(report.text)
+    return 0
+  }
+  if (!report.changed) {
+    return strict
+  }
+  if (flags.list || flags.check) {
+    process.stdout.write(name + '\n')
+  }
+  if (flags.diff) {
+    process.stdout.write(unifiedDiff(name, src, report.text))
+  }
+  if (flags.write) {
+    try {
+      writeFileSync(name, report.text)
+    }
+    catch (err: any) {
+      process.stderr.write(`aontu: cannot write ${name}: ${err.message}\n`)
+      return 2
+    }
+  }
+  return flags.check ? 1 : strict
+}
+
+
+// ---------------------------------------------------------------------
+// The servers as verbs: `aontu lsp` runs the language server and
+// `aontu mcp` the MCP server over the CLI's own streams, so the one
+// command on PATH is the editor's and the agent's server too, and a
+// version manager (docs/design/ENV.0.md) has one thing to resolve. The
+// standalone bins (aontu-lsp, aontu-mcp) run the same functions. Each
+// server owns its exit; the CLI only dispatches. The pair is a
+// parameter of main so that a test can see the dispatch without a
+// server taking the test's own stdin.
+
+type Servers = {
+  lsp: () => void
+  mcp: (argv: string[]) => void
+}
+
+// The real pair takes the process's own stdin and stdout, which no
+// in-process test can lend it; the executable-entry tests in
+// cli.test.ts run each through a child process instead, so these two
+// lines are excluded from the in-process count, as the stdio wiring
+// of lsp-server.ts is.
+/* node:coverage ignore next 4 */
+const SERVERS: Servers = {
+  lsp: () => void lspMain(),
+  mcp: (argv) => void mcpMain(undefined, undefined, undefined, undefined, argv),
+}
+
+// undefined: the server took the process; a number: an answer the CLI
+// gives itself, --help or a usage error.
+function runLsp(argv: string[], servers: Servers): number | undefined {
+  for (const arg of argv) {
+    if ('-h' === arg || '--help' === arg) {
+      process.stdout.write(HELP)
+      return 0
+    }
+    process.stderr.write(`aontu: lsp takes no arguments (try --help)\n`)
+    return 2
+  }
+  servers.lsp()
+  return undefined
+}
+
+
 function finish(code: number): void {
   process.exitCode = code
 }
@@ -3352,22 +3633,22 @@ function finish(code: number): void {
 // spelling, so the caller owns the usage error.
 function parseTrustArg(value: string): TrustArg | undefined {
   if ('system' === value) {
-    return { kind: 'system' }
+    return { kind: 'system', textExt: [] }
   }
   if ('none' === value) {
-    return { kind: 'none' }
+    return { kind: 'none', textExt: [] }
   }
   if ('root' === value) {
-    return { kind: 'root' }
+    return { kind: 'root', textExt: [] }
   }
   if (value.startsWith('root:') && 'root:'.length < value.length) {
-    return { kind: 'root', dir: value.slice('root:'.length) }
+    return { kind: 'root', dir: value.slice('root:'.length), textExt: [] }
   }
   return undefined
 }
 
 
-function main(argv: string[]): void {
+function main(argv: string[], servers: Servers = SERVERS): void {
   // COLOUR OFF WHEN THE DESTINATION IS NOT A TERMINAL. Error frames
   // hardcoded their ANSI escapes, so a piped report and a `--jsonl`
   // answer carried terminal control codes into whatever read them (the
@@ -3385,7 +3666,8 @@ function main(argv: string[]): void {
   // overwritten twice. In a tool loop that reads as a passing
   // validation. Counting them is what lets the refusal below happen.
   const files: string[] = []
-  let trust: TrustArg = { kind: 'system-warn' }
+  let trust: TrustArg = { kind: 'system-warn', textExt: [] }
+  let textExt: string[] = []
   // The REPL's SESSION protocol (G7 phase 7): one JSON line per
   // answer, so a harness can drive the session. Named --jsonl rather
   // than the design's --json, which would read as the `:json` output
@@ -3413,6 +3695,16 @@ function main(argv: string[]): void {
   if ('agentsmd' === argv[2]) {
     return finish(runAgentsMd(argv.slice(3)))
   }
+  if ('fmt' === argv[2]) {
+    return void Promise.resolve(runFmt(argv.slice(3))).then(finish)
+  }
+  if ('lsp' === argv[2]) {
+    const code = runLsp(argv.slice(3), servers)
+    return undefined === code ? undefined : finish(code)
+  }
+  if ('mcp' === argv[2]) {
+    return servers.mcp(argv.slice(3))
+  }
 
   if ('set' === argv[2]) {
     return finish(runSet(argv.slice(3)))
@@ -3492,7 +3784,17 @@ function main(argv: string[]): void {
         process.stderr.write('aontu: --include-root needs a directory\n')
         return finish(2)
       }
-      trust = { kind: 'root', dir }
+      trust = { kind: 'root', dir, textExt }
+    }
+    else if ('--text-ext' === arg) {
+      const list = null == args[i + 1] ? undefined : parseTextExt(args[++i])
+      if (null == list) {
+        process.stderr.write(
+          'aontu: --text-ext needs extensions, without dots' +
+          ' (--text-ext md,sql)\n')
+        return finish(2)
+      }
+      textExt = [...textExt, ...list]
     }
     else if (arg.startsWith('-')) {
       process.stderr.write(`aontu: unknown option ${arg} (try --help)\n`)
@@ -3519,6 +3821,11 @@ function main(argv: string[]): void {
     return finish(2)
   }
 
+  // The extensions ride with the capability from here on, so the three
+  // entry shapes below (file, REPL, stdin) each get them by threading
+  // the one value they already thread.
+  trust = { ...trust, textExt }
+
   const file = files[0]
   if (null != file) {
     finish(runFile(file, mode, trust))
@@ -3547,6 +3854,6 @@ export {
   runJsonSchema,
   runMod,
   runHash, runGet,
-  runWhy, renderWhyText, runSet, runAgentsMd,
+  runWhy, renderWhyText, runSet, runAgentsMd, runFmt,
   watchChange, watchSignature, vetWaiter, deprecatedAt,
 }