linersh 0.5.7 → 1.0.1

package/README.md

@@ -1,197 +1,122 @@
-# 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.
+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. If you are using one-shot
+`npx` instead of a global install, pass subcommands through the package:
+`npx --yes linersh@latest setup-js` or
+`npx --yes linersh@latest uninstall --yes`.
 
-For JavaScript-rendered pages, run the setup command from the same npm install:
+## Try It Cleanly
 
-```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:
+For a regular-user smoke test without touching your real Liner workspace:
 
 ```sh
-liner uninstall --yes
-```
-
-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`.
+tmp=$(mktemp -d)
+home="$tmp/home"
+cache="$tmp/npm-cache"
+projects="$tmp/projects"
+mkdir -p "$home" "$cache" "$projects"
 
-## Run
+HOME="$home" npm_config_cache="$cache" LINER_DIR="$projects" npx --yes linersh@latest --version
+HOME="$home" npm_config_cache="$cache" LINER_DIR="$projects" npx --yes linersh@latest
 
-```sh
-cd ~/projects/my-thing
-liner
+rm -rf "$tmp"
 ```
 
-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`).
+The second command opens the Go TUI. Create a test Liner Project, build the
+corpus with your configured local Claude or Codex runner, then run Create
+Operating Layer. Because `HOME`, the npm cache, and `LINER_DIR` all point inside
+`$tmp`, cleanup is just `rm -rf "$tmp"`.
+
+## Run Locally
 
-Override the workspace with `LINER_DIR`:
+From the repo root:
 
 ```sh
-LINER_DIR=~/mixtapes liner
+npm --prefix packages/tui 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:
+From this package:
 
 ```sh
-liner uninstall
-liner uninstall --yes
+npm run dev
 ```
 
-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 projects folder:
 
 ```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_DIR=/path/to/projects 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:
+Override the Python/core binary:
 
 ```sh
-LINER_BIN=/path/to/liner npm run dev
+LINER_BIN=/absolute/path/to/liner node bin/liner.js
 ```
 
-## Architecture
+## Build And Test
 
+```sh
+npm run build
+npm run build:go
+npm run build:package
+npm test
 ```
-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,69 @@ 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 headlessRunner = tryResolveHeadlessRunnerScript();
+  const child = spawn(resolved.command, resolved.args, {
+    stdio: "inherit",
+    cwd: resolved.cwd || process.cwd(),
+    env: {
+      ...process.env,
+      LINER_BIN: process.env.LINER_BIN || tryResolveCliCommand() || "",
+      LINER_HEADLESS_RUNNER: process.env.LINER_HEADLESS_RUNNER || headlessRunner || "",
+    },
+  });
+  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 +140,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 +282,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 +351,12 @@ 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 tryResolveHeadlessRunnerScript() {
+  const candidate = join(packageRoot, "dist", "agents", "headless-runner.js");
+  return existsSync(candidate) ? candidate : null;
 }
 
 function printVersion() {

package/cli-update-docs/README.md

@@ -1,6 +1,6 @@
 # Curating Mixtapes — Skill Bundle
 
-This is the Liner methodology made executable by Claude. The bundle implements CURATION.md v2.0 as instructions to a running AI, drives the mixtape lifecycle from a topic to a project folder ready for `liner compile`, and supports both quick mode (the AI does most of the work, the user confirms at two gates) and methodology mode (the curator engages substantively at every phase).
+This is the Liner methodology made executable by Claude or Codex. The bundle implements CURATION.md v2.0 as instructions to a running AI, drives the mixtape lifecycle from a task description to a project folder ready for `liner compile`, and supports both quick mode (the AI does most of the work, with lightweight gate review) and methodology mode (the curator engages substantively at every phase).
 
 It is one of Liner's surfaces, alongside the CLI, the TUI, the planned MCP server, and the planned web builder. The skill is the surface for Claude-Code-native and TUI-subprocess authoring. Methodology-mode curators can also use it directly when working in a Claude Code session.
 
@@ -18,7 +18,7 @@ curating-mixtapes/
 └── synthesis-guidance.md           # Phase 6
 ```
 
-`SKILL.md` is the orchestrator. It defines the trigger description, the two modes, the two gates, the eight-phase lifecycle skeleton, the AI biases to compensate for, the boundaries (what the skill does NOT do), and the failure modes to watch. It is always loaded when the skill fires.
+`SKILL.md` is the orchestrator. It defines the trigger description, the two modes, the review gates, the lifecycle skeleton, the AI biases to compensate for, the boundaries (what the skill does NOT do), and the failure modes to watch. It is always loaded when the skill fires.
 
 The five companion files are loaded only at the phases that use them. Phases 1, 3, 7, and 8 have no companion file — their guidance fits inside SKILL.md.
 
@@ -28,7 +28,7 @@ The split is deliberate. Every invocation pulls SKILL.md's ~2,300 words into con
 
 **Local testing.** Drop this directory into `~/.claude/skills/curating-mixtapes/`. Claude Code and Claude Desktop both look there for user-installed skills. The skill fires when the user says something the description matches — "help me make a mixtape on [topic]" is the canonical trigger.
 
-**Shipping.** The canonical bundle lives at repo-root `cli-update-docs/`. The TUI copies this directory into `packages/tui/cli-update-docs/` during `prepack` and ships it inside the `linersh` npm package, so end users do not need a separate skill install for TUI-driven agent phases.
+**Shipping.** The canonical bundle lives at `docs/curation-skill/`. The TUI copies this directory into `packages/tui/cli-update-docs/` during `prepack` and ships it inside the `linersh` npm package, so end users do not need a separate skill install for TUI-driven agent phases.
 
 **Direct skill use.** A documented copy/install flow for using the skill outside the TUI is still planned. Until then, direct local use is a developer workflow.
 
@@ -48,7 +48,7 @@ The user says something the description matches. Claude loads SKILL.md. Claude r
 
 At Phase 2, Claude reads `source-finding-tactics.md`. At Phase 4, Claude reads `source-quality-hierarchy.md` and `curator-notes.md`. At Phase 5, Claude reads `quality-check-tests.md`. At Phase 6, Claude reads `synthesis-guidance.md`. Each companion file is read at the start of its phase, before any work in that phase happens.
 
-The two gates pause for user input. In quick mode, the default is "looks good, continue" — Claude proceeds unless the user actively objects. In methodology mode, Claude pauses for substantive review.
+The gates pause for user input. In quick mode, defaults can auto-continue while preserving project state. In methodology mode, the AI pauses for substantive review.
 
 The skill writes artifacts to a project folder named for the topic (e.g., `mobile-design-foundations/`) as it goes. The working notes are produced phase by phase, so the user can stop at any phase boundary and resume later — the working files are picked up where they were left.
 
@@ -80,7 +80,7 @@ The bundle is functional and ships inside the npm TUI package so agent-backed ph
 
 The bundle still benefits from more worked examples in the companion files, but it is no longer blocked by the old "second pass before any shipping" constraint. Current product risk lives more in curation quality and fetcher edge cases than in basic skill availability.
 
-As of `linersh@0.5.5`, compilation is the product completion milestone. A project can be "ready to use — compiled with warnings" when `MIXTAPE.md` is written but some sources are missing or soft-failed. The TUI opens the existing compile result for a completed mixtape and requires an explicit retry/re-run from that screen.
+As of `linersh@1.0.0`, compilation is the corpus-ready milestone and Create Operating Layer is the project-complete milestone. A project can be "ready to use — compiled with warnings" when `MIXTAPE.md` is written but some sources are missing or soft-failed. The TUI opens the existing compile result for a completed mixtape and requires an explicit retry/re-run from that screen. Framing also has a validation contract: Phase 1 must produce a capability brief and required source roles before source discovery can proceed.
 
 ## Versioning
 
@@ -100,7 +100,7 @@ The skill is the methodology made executable. It sits alongside Liner's other su
 
 **The Liner CLI** runs `liner compile` against the project folder this skill produces. The skill never compiles; the CLI never authors. Clean split.
 
-**The Liner TUI** invokes this skill internally for quick-mode authoring via the Claude Agent SDK. Same methodology, different UX.
+**The Liner TUI** invokes this skill internally for agent-backed authoring via the local Claude or Codex CLI. Same methodology, different UX.
 
 **The Liner MCP server** (planned) will expose mechanical operations — fetch this URL, validate this tape file, query the cache — as tools. A future skill version will use those tools where v1 uses Claude's own web search.