linersh 0.5.6 → 1.0.0

package/README.md

@@ -1,197 +1,97 @@
-# Liner TUI
+# Liner NPM Shim And Runner Package
 
-Interactive authoring UI for [Liner](../..) — create, edit, compile, and share mixtape **project folders** from the keyboard.
+This package is still named `linersh` because it owns the published `liner`
+binary. It is no longer the React/Ink TUI implementation.
 
-A *tape file* (`tape.yaml`) is the recipe. A *mixtape* is the project folder Liner builds from it. The TUI is for authoring: it scaffolds folders, edits tapes, surfaces the synthesis status, then runs `liner compile` to produce the consumable `MIXTAPE.md` + `sources/` artifacts.
+Active responsibilities:
+
+- `bin/liner.js`: npm binary shim
+- Go TUI launcher for `packages/go-tui/` in development
+- TypeScript headless methodology runner under `src/agents/`
+- packaged curation skill bundle copied from `../../docs/curation-skill/` into
+  `cli-update-docs/`
+- optional per-platform packages that contain the native CLI and Go TUI
+  binaries for installed users
+
+The old React/Ink TUI has been decommissioned and is no longer part of the
+active package shape. `LINER_TUI=ink` intentionally fails with a decommissioning
+message.
 
 ## Install
 
 ```sh
-# One-shot:
 npx linersh
-
-# Persistent:
-npm install -g linersh    # adds `liner` to PATH
+npm install -g linersh
 liner
 ```
 
-The npm package includes the TUI and resolves the Python core from a per-platform optional package (`linersh-<platform>-<arch>`). With no arguments, `liner` opens the TUI. CLI subcommands such as `liner setup-js`, `liner compile`, `liner share`, and `liner status` pass through to the bundled core.
-
-For JavaScript-rendered pages, run the setup command from the same npm install:
-
-```sh
-liner setup-js
-```
-
-That command is idempotent and downloads the Playwright browser used for `render: js` and automatic JS-wall fallback (about 150MB). The TUI also offers this during first-run onboarding, and again from compile results if a source needs JS rendering. For debugging or local development, `LINER_BIN=/path/to/liner liner` overrides the bundled binary.
-
-To reset a machine for clean testing, run:
-
-```sh
-liner uninstall --yes
-```
+With no arguments, `liner` launches the Go TUI. CLI subcommands such as
+`liner compile`, `liner share`, `liner import`, `liner status`, and
+`liner setup-js` pass through to the Python core.
 
-This removes `~/.liner`, Playwright's Chromium cache, and npm's `_npx` execution cache. It does not delete your mixtape project folders. If you installed Liner globally, also run `npm uninstall -g linersh`.
+## Run Locally
 
-## Run
+From the repo root:
 
 ```sh
-cd ~/projects/my-thing
-liner
+npm --prefix packages/tui run dev
 ```
 
-The TUI looks for (and creates) a `./mixtapes/` folder in your current directory. Each subdirectory inside it is a mixtape project folder (must contain a `tape.yaml`).
-
-Override the workspace with `LINER_DIR`:
+From this package:
 
 ```sh
-LINER_DIR=~/mixtapes liner
+npm run dev
 ```
 
-## Keys
-
-### Browser
-| Key | Action |
-|---|---|
-| `↑` `↓` or `j` `k` | move selection |
-| `enter` or `o` | open the selected mixtape hub |
-| `e` | open the selected mixtape source editor |
-| `n` | new mixtape (prompts for slug) |
-| `c` | compile selected |
-| `s` | share selected (zip to `.mixtape`) |
-| `i` | import a `.mixtape` archive |
-| `d` | delete selected folder (with confirm) |
-| `r` | refresh |
-| `q` | quit |
-
-### Project Hub
-| Key | Action |
-|---|---|
-| `↑` `↓` | select phase |
-| `enter` | run/open the selected phase's primary action |
-| `e` | edit the selected artifact by hand |
-| `p` | open the process manifest |
-| `s` | share the mixtape |
-| `o` | open the project folder |
-| `esc` | back |
-| `q` | quit |
-
-Completed mixtapes land in a ready state. If `MIXTAPE.md` is current, pressing `enter` on Compile opens the existing compile result instead of fetching sources again. Press `r` from the compile result screen to explicitly re-run/retry.
-
-### Source Editor
-| Key | Action |
-|---|---|
-| `t` `d` `u` | edit title / description / curator |
-| `m` | toggle mode (`quick` ⇄ `methodology`) |
-| `g` | edit JTBD (job-to-be-done) |
-| `E` | open `synthesis.md` in `$EDITOR` |
-| `↑` `↓` | select source |
-| `a` `e` `x` | add / edit / remove source |
-| `K` `J` | reorder selected source up/down |
-| `s` | save `tape.yaml` |
-| `c` | save + compile (blocked if synthesis is empty or still a placeholder) |
-| `esc` | back (warns on unsaved changes) |
-
-A soft warning appears when any source is missing a curator note. Notes are load-bearing — see [CURATION.md](https://liner.sh) §6.
-
-#### Local sources
-
-`local_file` sources reference content you've placed under `<project>/personal/` — book chapter PDFs, Reader-Mode-saved articles, exported HIG pages. Use them for material that isn't on the public web or that lives behind a paywall you have legitimate access to.
-
-Workflow:
-
-1. Save the file into `<project>/personal/`. The TUI creates the folder lazily — the file picker offers a "new file (paste path)" option that you can use after saving the file manually with your OS file manager.
-2. Add a source in the editor; press `T` in the source modal to switch the type to `local_file`.
-3. Pick the file via the picker; supply a `citation` (author, title, publication, date — the AI uses this to weight the source).
-4. Compile. The CLI extracts the content (PDFs via `pdfplumber`, HTML via the same readability pipeline as web sources, `.md`/`.txt` as-is).
-
-`liner share` includes `personal/` by default. Pass `--no-personal` (or use the corresponding TUI flag) to exclude it — required for any tape intended as a library submission.
-
-The synthesis indicator shows one of:
-- `✗ missing` — `liner compile` will hard-fail
-- `⚠ placeholder` — file exists but still has the boilerplate from `liner init`
-- `⚠ empty` — file exists but is empty
-- `✓ N chars` — ready to compile
-
-### Source modal
-| Key | Action |
-|---|---|
-| `↑` `↓` | move between fields |
-| `enter` | edit the focused field (or open the file picker on the path field for `local_file` sources) |
-| `tab` | next field while editing |
-| `T` | toggle source type (`web` ⇄ `local_file`) |
-| `R` | toggle `render: server` ⇄ `render: js` (web sources only) |
-| `p` | toggle required/optional |
-| `s` | save source |
-| `esc` | cancel |
-
-For `web` sources the URL is the load-bearing field; the type is auto-detected as `youtube` or `web`. For `local_file` sources the modal shows `path`, `citation`, `note`, `section`, `priority` — pick the path via the file picker (lists files under `personal/`, with a "paste path" affordance for new files).
-
-### Compile
-| Key | Action |
-|---|---|
-| `↑` `↓` | scroll sources |
-| `pgup` `pgdn` | jump through sources |
-| `j` | install JS rendering support when the result says it is needed |
-| `esc` | cancel running compile |
-| `y` | copy compiled `MIXTAPE.md` to clipboard (`pbcopy` / `xclip`) |
-| `s` | share the compiled mixtape (zip to `.mixtape`) |
-| `o` | open the project folder |
-| `r` | retry failed sources / re-run compile |
-| `b` | back to hub |
-| `q` | quit |
-
-The compile writes `MIXTAPE.md` and `sources/NN-<slug>.md` files directly into the project folder. A partial compile is still treated as a usable finished state when `MIXTAPE.md` is written; the hub shows "compiled with warnings" and the compile result screen lists the remaining warnings. There's nothing to "save" afterwards — the artifacts are already on disk.
-
-## Uninstalling
-
-The TUI ships in the same `linersh` package as the CLI. For npm/npx installs, use the package uninstaller:
+Override the projects folder:
 
 ```sh
-liner uninstall
-liner uninstall --yes
+LINER_DIR=/path/to/projects node bin/liner.js
 ```
 
-It removes `~/.liner`, Playwright's Chromium cache, and npm's `_npx` execution cache. Your mixtape project folders are left alone. If you installed Liner globally, also run `npm uninstall -g linersh`. See the root [README — Uninstalling](../../README.md#uninstalling) for the manual recipe.
-
-## Develop
+Override the Python/core binary:
 
 ```sh
-cd packages/tui
-npm install
-npm run dev          # tsx (no watch — Ctrl+C and re-run after code changes)
-npm run dev:built    # builds, then runs the compiled output (closer to ship)
-npm run typecheck
-npm test             # vitest
-npm run build        # emits dist/
+LINER_BIN=/absolute/path/to/liner node bin/liner.js
 ```
 
-**Why no `tsx watch`?** `tsx watch` keeps the TTY in raw mode for its own restart UI (Enter to restart, "rs" to force, Esc to clear). Ink TUIs also want raw stdin, and the two collide — typed characters get eaten, the app gets surprise-restarted, screens flicker. For interactive UIs, restart manually after code changes.
-
-In dev, the bin-resolver tries `LINER_BIN`, the bundled optional package, the repo-local `.venv/bin/liner`, then `liner` on `$PATH`. To point at a specific binary:
+## Build And Test
 
 ```sh
-LINER_BIN=/path/to/liner npm run dev
+npm run build
+npm run build:go
+npm run build:package
+npm test
 ```
 
-## Architecture
-
-```
-BootSplash ─────► TapeBrowser ──────► ProjectHub ──────┐
-       │                            │
-       │          ImportPrompt ─────┤
-       │                            │
-       ├────► NewProjectWizard ─────┤
-       │                            │
-       ├────► TapeEditor ⇄ SourceModal
-       │                            │
-       ├────► PhaseRunner / gates / draft review
-       │                            │
-       └────► CompileView (streams NDJSON from `liner compile --emit-events`)
-```
-
-State is global via `AppContext`. YAML is parsed and re-written in Node via the `yaml` package's `Document` API so user-written block comments survive edits. All folder operations (`init`, `compile`, `share`, `import`, `list`) go through the Python CLI as subprocesses — the TUI never reimplements them.
-
-The CLI's `compile --emit-events` streams NDJSON progress events to stdout; the TUI parses each line and updates per-source state live. The final `result` event reports the produced folder, `MIXTAPE.md` path, and per-source file paths.
-
-The same NDJSON protocol will power the planned MCP server, which calls into the same Python core directly without going through the CLI.
+Notes:
+
+- `build` compiles the TypeScript headless runner and shared runner utilities.
+- `build:go` compiles `../go-tui/cmd/liner-tui` into `bin/liner-tui` for local
+  development.
+- `build:package` runs both.
+- Release packaging is verified with `npm run acceptance:go -- release-smoke`,
+  which packs a local platform package plus the main `linersh` package and
+  installs both into a clean consumer project.
+
+## Useful Environment Variables
+
+- `LINER_DIR=/path/to/projects`: change the projects folder.
+- `LINER_BIN=/path/to/liner`: force the Python/core binary.
+- `LINER_GO_TUI_BIN=/path/to/liner-tui`: force the Go TUI binary.
+- `LINER_HEADLESS_RUNNER=/path/to/headless-runner.js`: force the methodology
+  runner script.
+- `LINER_AGENT=codex|claude`: override the agent selected by Liner config.
+- `LINER_TUI=go`: accepted for compatibility, but no longer required.
+
+## Developer Gotchas
+
+- Rebuild `bin/liner-tui` after Go changes or the npm shim may launch an older
+  binary.
+- Rebuild `dist/` after TypeScript runner changes or methodology will fail.
+- The published main package intentionally excludes `bin/liner-tui`; installed
+  users get the native TUI from `linersh-<platform>-<arch>`.
+- If Project Health says `status failed`, check the resolved core. Older bundled
+  cores may reject `--no-write`; the Go wrapper has a fallback, but direct
+  `node bin/liner.js status ... --no-write` can still fail until platform cores
+  are refreshed.

package/bin/liner.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 // Entry shim for `npx linersh` / `liner`.
 //
-// No args: launch the Ink TUI from dist/.
+// No args: launch the selected TUI.
+//   unset         -> launch the Charm Go TUI
+//   LINER_TUI=go  -> launch the Charm Go TUI explicitly
 // CLI args: forward to the bundled Python core (or LINER_BIN/dev fallback).
 //
 // This lets the npm package expose one binary name while still supporting
@@ -41,6 +43,7 @@ const CLI_COMMANDS = new Set([
   "clone",
   "setup-js",
   "list",
+  "skills",
   "cache",
   "manifest",
   "status",
@@ -66,44 +69,67 @@ if (wantsCli(argv)) {
     process.exit(code ?? 1);
   });
 } else {
-  // Enter the terminal's alternate screen buffer before launching Ink.
-  //
-  // Every Ink screen that changes total render height between frames (each
-  // wizard step, each PhaseRunner stream event, each gate transition) was
-  // committing older frames to the user's scrollback — producing stacked
-  // duplicated headers above the visible content. The alternate buffer has
-  // no scrollback by definition, so the bug class is eliminated.
-  //
-  // Trade-off: on exit, the TUI vanishes and the terminal returns to its
-  // pre-launch state. Post-exit context lives in `.liner-runs/` and
-  // `MIXTAPE.md`, which are the intended sources of truth anyway.
-  //
-  // Only enter alt-screen on a real TTY; piped/redirected stdout shouldn't
-  // receive raw escape sequences.
-  const useAltScreen = process.stdout.isTTY === true;
-
-  if (useAltScreen) {
-    process.stdout.write("\x1b[?1049h");
-    const restoreScreen = () => {
-      process.stdout.write("\x1b[?1049l");
-    };
-    process.on("exit", restoreScreen);
-    process.on("SIGINT", () => {
-      restoreScreen();
-      process.exit(130);
-    });
-    process.on("SIGTERM", () => {
-      restoreScreen();
-      process.exit(143);
-    });
-    process.on("uncaughtException", (err) => {
-      restoreScreen();
-      console.error(err);
-      process.exit(1);
-    });
+  const tui = (process.env.LINER_TUI || "go").toLowerCase();
+  if (tui !== "go") {
+    console.error(
+      [
+        `Unsupported LINER_TUI value: ${process.env.LINER_TUI}`,
+        "",
+        "The Ink TUI has been decommissioned and moved to the repo's ink/ archive.",
+        "Run `liner` with no LINER_TUI override, or set LINER_TUI=go.",
+      ].join("\n"),
+    );
+    process.exit(1);
   }
 
-  await import(join(packageRoot, "dist", "index.js"));
+  const resolved = resolveGoTuiBinary();
+  const child = spawn(resolved.command, resolved.args, {
+    stdio: "inherit",
+    cwd: resolved.cwd || process.cwd(),
+    env: {
+      ...process.env,
+      LINER_BIN: process.env.LINER_BIN || tryResolveCliCommand() || "",
+    },
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 1);
+  });
+}
+
+function resolveGoTuiBinary() {
+  const envBin = process.env.LINER_GO_TUI_BIN;
+  if (envBin && existsSync(envBin)) return { command: envBin, args: [] };
+
+  const packaged = join(packageRoot, "bin", process.platform === "win32" ? "liner-tui.exe" : "liner-tui");
+  if (existsSync(packaged)) return { command: packaged, args: [] };
+
+  const bundled = findBundledGoTuiBinary();
+  if (bundled) return { command: bundled, args: [] };
+
+  const sourceDir = join(packageRoot, "..", "go-tui");
+  if (existsSync(join(sourceDir, "go.mod"))) {
+    const go = spawnSync("go", ["version"], { encoding: "utf8" });
+    if (go.status === 0) {
+      return { command: "go", args: ["run", "./cmd/liner-tui"], cwd: sourceDir };
+    }
+  }
+
+  console.error(
+    [
+      "Could not find the Go Liner TUI.",
+      "",
+      "Expected one of:",
+      "  - LINER_GO_TUI_BIN=/path/to/liner-tui",
+      "  - packages/tui/bin/liner-tui built by npm run build:go",
+      "  - bundled platform package (linersh-<platform>-<arch>)",
+      "  - repo source at packages/go-tui with go installed",
+    ].join("\n"),
+  );
+  process.exit(1);
 }
 
 function resolveCliBinary() {
@@ -112,12 +138,12 @@ function resolveCliBinary() {
     return { command: envBin, args: [] };
   }
 
-  const bundled = findBundledBinary();
-  if (bundled) return { command: bundled, args: [] };
-
   const repoVenv = findRepoVenvBinary();
   if (repoVenv) return { command: repoVenv, args: [] };
 
+  const bundled = findBundledBinary();
+  if (bundled) return { command: bundled, args: [] };
+
   const pathHit = findPathBinary();
   if (pathHit) return { command: pathHit, args: [] };
 
@@ -254,13 +280,25 @@ function playwrightCachePath(home) {
 }
 
 function findBundledBinary() {
+  const baseDir = findBundledPackageDir();
+  if (!baseDir) return null;
+  const candidate = join(baseDir, exeName());
+  return existsSync(candidate) ? candidate : null;
+}
+
+function findBundledGoTuiBinary() {
+  const baseDir = findBundledPackageDir();
+  if (!baseDir) return null;
+  const candidate = join(baseDir, process.platform === "win32" ? "liner-tui.exe" : "liner-tui");
+  return existsSync(candidate) ? candidate : null;
+}
+
+function findBundledPackageDir() {
   const require = createRequire(import.meta.url);
   const target = `linersh-${process.platform}-${process.arch}`;
   try {
     const pkgJson = require.resolve(`${target}/package.json`);
-    const baseDir = pkgJson.replace(/[\\/]package\.json$/, "");
-    const candidate = join(baseDir, exeName());
-    return existsSync(candidate) ? candidate : null;
+    return pkgJson.replace(/[\\/]package\.json$/, "");
   } catch {
     return null;
   }
@@ -311,7 +349,7 @@ function readTuiVersion() {
 function tryResolveCliCommand() {
   const envBin = process.env.LINER_BIN;
   if (envBin && existsSync(envBin)) return envBin;
-  return findBundledBinary() || findRepoVenvBinary() || findPathBinary() || null;
+  return findRepoVenvBinary() || findBundledBinary() || findPathBinary() || null;
 }
 
 function printVersion() {

package/cli-update-docs/ABOUT.md

@@ -15,25 +15,25 @@ Liner treats curation as the work and produces a portable artifact.
 Liner is several things sharing a methodology and a file format:
 
 - **A CLI** for compiling mixtape projects
-- **A TUI** for the multi-step authoring lifecycle
+- **A Go TUI** for the multi-step authoring lifecycle
 - **A skill** that runs the methodology inside Claude
-- **An MCP server** that exposes the same functions to any agent (Claude Code, Codex, Cursor, others)
-- **A library** of curated mixtapes anyone can clone, fork, or run as-is
+- **A planned MCP server** that will expose the same functions to any agent (Claude Code, Codex, Cursor, others)
+- **A planned library** of curated mixtapes anyone can clone, fork, or run as-is
 - **A methodology** documented in [CURATION.md](./CURATION.md) and applied across all the above
 
-The pieces are independent. The CLI works without the TUI. The skill works without the CLI. The MCP server works in any agent host. Users pick the surface that fits their workflow.
+The implemented pieces are independent. The CLI works without the TUI. The skill works without the CLI. The planned MCP server will add an agent-native surface later. Users pick the surface that fits their workflow.
 
 ## What a mixtape is
 
-A mixtape is a project folder containing:
+A mixtape is the corpus inside a Liner project folder. In v2 projects it lives under `mixtape/`; legacy root-level mixtape folders remain readable. The corpus contains:
 
-- A **recipe** (`tape.yaml`) — the curated list of sources with notes and sections
-- A **synthesis** — the curator's distilled understanding of the domain
-- **Source content** — extracted text from every source in the recipe
-- **Working notes** — the methodology's traces: JTBD, knowledge map, evaluation, quality checks
-- A **master file** (`MIXTAPE.md`) — the consumable artifact, with the synthesis up front and sources referenced by file
+- A **recipe** (`mixtape/tape.yaml`) — the curated list of sources with notes and sections
+- A **synthesis** (`mixtape/synthesis.md`) — the curator's distilled understanding of the domain
+- **Source content** (`mixtape/sources/`) — extracted text from every source in the recipe
+- **Working notes** (`mixtape/working/`) — the methodology's traces: JTBD, capability brief, knowledge map, source roles, evaluation, quality checks
+- A **master file** (`mixtape/MIXTAPE.md`) — the consumable artifact, with the synthesis up front and sources referenced by file
 
-The recipe is small, shareable, and recompilable. The mixtape folder is heavier, self-contained, and ready to paste into an AI conversation. The two artifacts have different sharing properties and different purposes.
+The recipe is small, shareable, and recompilable. The full Liner project folder is heavier, self-contained, and ready to hand to an AI session. The two artifacts have different sharing properties and different purposes.
 
 ## Who Liner is for
 
@@ -47,22 +47,22 @@ A few decisions that distinguish Liner from adjacent tools:
 
 - **Curation is the work.** The methodology is the product, not an afterthought. Tools that auto-generate context bundles produce mediocre results because they skip the judgment step. Liner is structured around making that judgment easier.
 - **Portable artifacts.** Mixtape folders are plain text — YAML and Markdown. They can be edited by hand, generated by tools, shared in repositories, and forked into derivatives. Nothing is locked into a platform.
-- **No hosted backend.** Liner doesn't run a service. The CLI runs locally. The library is a static repository. The website is a static site. No accounts, no servers, no infrastructure that can disappear.
-- **Two modes, same architecture.** Quick mode runs the methodology automatically; methodology mode runs it with substantive curator involvement. Same files, same format, different intensity. The library accepts methodology-mode mixtapes; personal use is whatever the curator wants.
+- **No hosted backend.** Liner doesn't run a service. The CLI runs locally. The planned library will be a static repository. The website is a static site. No accounts, no servers, no infrastructure that can disappear.
+- **Two modes, same architecture.** Quick mode runs the methodology automatically; methodology mode runs it with substantive curator involvement. Same files, same format, different intensity. The planned library will accept methodology-mode mixtapes; personal use is whatever the curator wants.
 - **Multiple surfaces, one methodology.** The same curation process applies whether the user is in the terminal, in a Claude conversation, or driving an agent. The methodology document is the source of truth; everything else implements it.
 
 ## How the pieces fit together
 
 - The **methodology** ([CURATION.md](./CURATION.md)) defines how to curate well.
 - The **mixtape format** ([MIXTAPE-FORMAT.md](./MIXTAPE-FORMAT.md)) defines what a mixtape folder contains and how `tape.yaml` is structured.
-- The **platform** ([PLATFORM.md](./PLATFORM.md)) defines how the Liner project specifically operates — the library, the contribution process, the boundaries.
-- The **tools** (CLI, TUI, skill, MCP server) implement the methodology and consume the format.
+- The **platform** ([PLATFORM.md](./PLATFORM.md)) defines how the Liner project specifically operates — implemented surfaces, planned surfaces, the future library, the contribution process, and the boundaries.
+- The **tools** (CLI, Go TUI, skill, and planned MCP server) implement the methodology and consume the format.
 
 A curator who learns the methodology can apply it with or without Liner's tools. A curator using Liner's tools can produce mixtapes that exist outside the Liner ecosystem. The methodology, the format, and the tools compose without locking into each other.
 
 ## Project status
 
-Active development. The CLI and TUI are both functional and published on npm (current release v0.5.5, Mac, Linux, and Windows x64). Both support the full v1.1 tape format — `youtube`, `web`, and `local_file` sources, with optional Playwright-backed JavaScript rendering for sites that need it (`liner setup-js`, surfaced by the TUI during onboarding and compile warnings). The TUI now treats compilation as the completion milestone and opens existing compile results instead of rerunning by default. The library is empty pending its first methodology-mode entries. The `curating-mixtapes` skill ships inside the TUI package; the MCP server is planned. Maintained as a side project — see [PLATFORM.md](./PLATFORM.md) for the maintenance contract.
+Active development. The CLI and Go TUI are both functional and published on npm (current release v1.0.0, Mac, Linux, and Windows x64). They support the current tape format — `youtube`, `web`, `local_file`, and `skill` sources, with optional Playwright-backed JavaScript rendering for sites that need it (`liner setup-js`, surfaced by the TUI during onboarding and compile warnings). The TUI treats compilation as the corpus-ready milestone, opens existing compile results instead of rerunning by default, validates Phase 1 framing before source discovery can proceed, and creates an Operating Layer with `LINER.md`, root `SKILL.md`, and `liner.yaml`. The public library and MCP server are planned. The `curating-mixtapes` skill ships inside the TUI package. Maintained as a side project — see [PLATFORM.md](./PLATFORM.md) for the maintenance contract.
 
 ## License