Remove CLI and Tracer app integrations

Author: adrida

.github/workflows/ci.yml

@@ -28,3 +28,19 @@ jobs:
 
       - name: Run tests
         run: pytest tests/ -v --tb=short
+
+  watch-js:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: js
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: npm
+          cache-dependency-path: js/package-lock.json
+      - run: npm ci
+      - run: npm test -- --maxWorkers=1 --minWorkers=1
+      - run: npm run build

AGENTS.md

@@ -154,8 +154,8 @@ router = tracer.load_router(".tracer", embedder=my_embedder)
 ```
 
 ### Pattern 4: HTTP server (zero deps)
-```bash
-tracer serve .tracer --port 8000
+```python
+tracer.serve(".tracer", port=8000)
 # POST /predict {"embedding": [...]} → {"label", "decision", "accept_score"}
 ```
 
@@ -173,7 +173,7 @@ tracer serve .tracer --port 8000
 ## Things you CAN do autonomously
 
 - Install `tracer-llm` (it's lightweight, MIT licensed)
-- Run `tracer demo` to show the user what it does
+- Follow `notebooks/01-quickstart.ipynb` for a worked example
 - Write traces to JSONL from any data source
 - Fit a policy if traces + embeddings are available
 - Generate the HTML report
@@ -195,7 +195,6 @@ tracer serve .tracer --port 8000
 | `Embedder.from_endpoint(url)` | External embedding API | Needs URL + auth from human |
 | `tracer.generate_html_report(dir)` | Visual audit | No |
 | `tracer.serve(dir, port=8000)` | HTTP server | No |
-| `tracer demo` | Interactive demo | No |
 
 ---
 

CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to TRACER are recorded here. This project follows semantic
 versioning.
 
+## Unreleased
+
+### Removed (breaking)
+- The `tracer` command-line executable and command implementations. Use the
+  Python APIs for fitting, scanning, updating, reports, and serving predictions.
+- The Tracer app client, authentication, and automatic app telemetry exporters
+  in both Python and JavaScript. Existing app credentials no longer trigger
+  uploads. Local recording, custom sinks, and explicitly configured generic
+  HTTP exports remain available.
+- App connection instructions and command-line documentation. All current
+  examples use the library APIs.
+
 ## 0.3.3 (2026-06)
 
 ### Fixed
@@ -20,48 +32,27 @@ versioning.
   `ValueError` messages. Previously the count excluded blank lines, so
   the reported line was lower than the actual position of the bad record.
 
-## 0.3.1 (2026-06)
-
-### Changed
-- `tracer cloud` commands that take a tracer (`get`, `training`, `analytics`,
-  `label-space`, `traces`, ...) now accept either the tracer slug or its id.
-- `tracer cloud scan` works without logging in, matching the public web scan.
-
-### Fixed
-- `tracer cloud keys create` and `tracer cloud ingest-keys create` now honor
-  `--json` and emit the created record (including the one-time secret) as JSON.
-
 ## 0.3.0 (2026-06)
 
 ### Added
-- `tracer.watch`: a decorator (and HTTP fallback) that observes the LLM calls
-  your pipeline already makes and ships them, free, to Tracer Cloud, where they
-  accumulate and auto-optimize once there are enough. Captures the full request
-  and response on the OpenTelemetry GenAI (`gen_ai.*`) schema, with pluggable
-  sinks (local file, Tracer Cloud, OTLP, or several at once).
+- `tracer.watch`: a decorator that records LLM calls on the OpenTelemetry
+  GenAI (`gen_ai.*`) schema, with pluggable local and generic export sinks.
 - `@tracer-llm/watch`: a zero-dependency JavaScript/TypeScript mirror of the watch
   decorator (async-context aware), so JS pipelines get the same one-line
   observability as Python.
-- `tracer cloud`: a full command-line interface for Tracer Cloud, at parity with
-  the dashboard. Browser or password login, then manage tracers (create, quick
-  and bulk uploads, agentic `onboard`, rename, delete), training (retrain,
-  auto-retrain, promote/rollback, live status), routing (`route`), test
-  batteries, the model library, API keys, observability ingest keys, billing,
-  analytics, trace selection (`traces`), and a public `scan`.
 - Lazy package initialization so `import tracer` stays fast and only pulls in the
   heavy pieces when you actually use them.
 
 ### Changed
-- `tracer scan` is more robust on messy uploads: tolerant input/label aliasing
-  and a clarification path so ambiguous files still produce a result.
+- Trace ingestion accepts additional input and label aliases.
 
 ### Docs
-- New guides for the watch decorator and the `tracer cloud` CLI.
+- New guide for the watch decorator.
 
 ## 0.2.0 (2026-06)
 
 ### Added
-- `tracer scan`: a fast, conservative day-one read of a traces file, before any
+- `tracer.scan()`: a fast, conservative day-one read of a traces file, before any
   training. It groups traffic by similarity and measures, on a held-out slice it
   never saw, how much a near-free model can answer at your target agreement,
   using exact Clopper-Pearson bounds, with an optional per-1k and monthly savings
@@ -72,24 +63,20 @@ versioning.
   far from the training distribution (kNN distance, global and per-predicted-label
   thresholds) regardless of surrogate confidence, so off-distribution traffic goes
   to the teacher instead of getting a confident guess.
-- `tracer fit --trees` to opt in the tree surrogates, and `--skip` to drop named
-  candidates from the zoo.
+- `FitConfig.skip_candidates` to drop named candidates from the zoo, including
+  tree surrogates when a lighter sweep is desired.
 - Trace loaders accept common key aliases for both input and label
   (`input/query/text/prompt/question` and
   `teacher/teacher_output/label/intent/output/answer`).
-- Bring-your-own embeddings for `tracer scan`: local sentence-transformers by
-  default (`--embed-model`), a precomputed `.npy` (`--embeddings`), or your own
-  HTTP embedding endpoint (`--embed-url`, with header and response-key options).
+- Bring-your-own embeddings for `tracer.scan()`: pass a precomputed array with
+  `embeddings=`, or select a local sentence-transformers model with `model=`.
 
 ### Changed
 - The parity gate now certifies on an exact held-out lower bound instead of an
   in-sample point estimate, so a policy cannot clear the target by in-sample luck
   and then break the contract on real traffic. Coverage is now monotonic in the
   target, and a hybrid select-then-verify procedure recovers coverage at strict
   targets that a plain held-out split discarded.
-- Tree surrogates (decision tree, random forest, extra-trees, gradient boosting)
-  are now off by default in `tracer fit`; the default zoo is the fast linear and
-  MLP heads. Use `--trees` for hard, high-class-count tasks.
 - The HTML report is restyled to the light Tracer theme, and the word "audit" is
   dropped across the report and docs.
 

CONTRIBUTING.md

@@ -68,13 +68,20 @@ pip install -e ".[dev]"
 pytest tests/ -v
 ```
 
-Tests use synthetic data and run in temporary directories. No external
-dependencies or API keys required.
+Tests use synthetic data and run in temporary directories. No model downloads
+or API keys are required. To check the JavaScript recorder:
+
+```bash
+cd js
+npm ci
+npm test -- --maxWorkers=1 --minWorkers=1
+npm run build
+```
 
 ## Quick sanity check
 
 ```bash
-tracer demo
+pytest tests/test_router.py tests/test_watch.py -q
 ```
 
 ## Project structure
@@ -101,9 +108,8 @@ src/tracer/
   runtime/
     router.py            <- production Router class
     serve.py             <- lightweight HTTP prediction server (stdlib only)
-  cli/
-    main.py              <- tracer CLI entry point (fit, report, update, demo, serve)
-    _ui.py               <- terminal formatting and progress display
+  scanner.py             <- pre-training traffic diagnostics and reports
+  watch.py               <- local trace recording and generic export sinks
 ```
 
 ## Adding a new surrogate model

README.md

@@ -11,7 +11,6 @@
 [![npm](https://img.shields.io/npm/v/@tracer-llm/watch?label=%40tracer-llm%2Fwatch&color=cb3837&logo=npm)](https://www.npmjs.com/package/@tracer-llm/watch)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![CI](https://img.shields.io/badge/CI-passing-brightgreen)](https://github.com/adrida/tracer/actions)
-[![Website](https://img.shields.io/badge/website-tracerml.ai-blue)](https://tracerml.ai)
 [![Docs](https://img.shields.io/badge/docs-reference-blue)](docs/)
 
 Most LLM-based classification pipelines use a large language model for every single input. In practice, the vast majority of that traffic is predictable - a lightweight traditional ML model (logistic regression, gradient-boosted trees, or a small neural net) can match the LLM's output with near-perfect agreement.
@@ -22,25 +21,6 @@ TRACER learns the decision boundary between "easy" and "hard" inputs directly fr
 pip install tracer-llm
 ```
 
-## See it work
-
-```bash
-tracer demo
-```
-
-```
-  TRACER  Demo - Banking77 (77 intents · 1,500 traces)
-
-  Routing Policy
-  method      l2d
-  coverage    91.4%   of traffic handled by surrogate
-  teacher TA  0.920   surrogate matches teacher on handled traffic
-
-  Cost Projection (10k queries/day)
-      Without TRACER   10,000 LLM calls/day   $20.00/day
-      With TRACER         863 LLM calls/day   $ 1.73/day   $6,670 saved/yr
-```
-
 ## Quickstart
 
 Input: a JSONL file where each line contains the original text (`input`) and the label your LLM assigned (`teacher`).
@@ -63,10 +43,11 @@ out = router.predict("What is my balance?")
 # 3. Fallback - only invokes the LLM when the surrogate declines
 out = router.predict("Some edge case", fallback=lambda: call_my_llm(text))
 ```
+The [API reference](docs/api.md) covers fitting, routing, updates, and reports.
+See [concepts](docs/concepts.md) for the pipeline and [watch](docs/watch.md) for
+local trace recording and opt-in exports to your own backend.
 
-> **Want to go deeper?** The [concepts guide](docs/concepts.md) explains the full pipeline, model zoo, and parity gate. The [API reference](docs/api.md) covers every parameter. The [CLI reference](docs/cli.md) covers `tracer fit`, `tracer serve`, and more. For observability see [watch](docs/watch.md), and to drive Tracer Cloud from your shell see the [`tracer cloud` reference](docs/cloud.md).
-
-## Watch your LLM traffic (free observability)
+## Watch your LLM traffic
 
 Before you fit anything, just *watch*. Wrap any LLM call and every request is
 recorded locally as an OpenTelemetry GenAI span, no account, no key, nothing
@@ -82,21 +63,12 @@ def classify(ticket: str) -> str:
     return call_my_llm(ticket)   # traces append to .tracer/watch/*.jsonl
 ```
 
-Want them in a dashboard? Tracer Cloud observability is **free**. Mint a key
-(`tracer cloud ingest-keys create`, or the Watch page in the app) and set one
-env var, your traffic streams in within seconds, prod-safe (batched, never adds
-latency or throws):
-
-```bash
-export TRACER_CLOUD_KEY=trobs_...   # or watch(..., cloud_key="trobs_...")
-```
-
 The same watched spans map 1:1 to `TraceRecord`, so once you have traffic you can
-`tracer fit` a router from it. Full guide: [docs/watch.md](docs/watch.md).
+call `tracer.fit()` to train a router from it. Full guide: [docs/watch.md](docs/watch.md).
 
 ## Using from JavaScript / Node.js
 
-**Watch your JS LLM calls (free observability):** [`@tracer-llm/watch`](https://www.npmjs.com/package/@tracer-llm/watch) mirrors the Python decorator with zero dependencies, recording every call as an OpenTelemetry GenAI span (local by default, or streamed free to Tracer Cloud).
+**Watch your JS LLM calls (free observability):** [`@tracer-llm/watch`](https://www.npmjs.com/package/@tracer-llm/watch) mirrors the Python decorator with zero dependencies, recording every call as an OpenTelemetry GenAI span (local by default, with opt-in export to your own backend).
 
 ```bash
 npm install @tracer-llm/watch
@@ -111,14 +83,14 @@ const w = watch("support_classifier", { system: "provider-x", model: "model-x" }
 const classify = w(async (ticket) => callYourLLM(ticket));
 ```
 
-Full guide: [docs/javascript.md](docs/javascript.md). To route (not just observe) from JS, log traces, fit offline with the CLI, run `tracer serve` as a sidecar, and call it via `fetch`:
+Full guide: [docs/javascript.md](docs/javascript.md). To route (not just observe) from JS, log traces, fit offline with `tracer.fit()`, run `tracer.serve()` in a Python sidecar, and call it via `fetch`:
 
 ```js
 // 1. Log every LLM classification
 fs.appendFileSync('traces.jsonl', JSON.stringify({ input: text, teacher: label }) + '\n')
 
 // 2. At inference: embed → POST to TRACER → fallback to LLM only if deferred
-const { label, decision } = await fetch('http://localhost:8000/predict', {
+let { label, decision } = await fetch('http://localhost:8000/predict', {
   method: 'POST',
   body: JSON.stringify({ embedding }),  // same model you used at fit time
 }).then(r => r.json())
@@ -139,7 +111,7 @@ User query → [Embedder] → [ML Surrogate] → [Acceptor Gate]
                                           (traditional ML)
 ```
 
-The surrogate is **not another LLM** - it is a classical ML or shallow DL model. By default the zoo is lightweight and fast (logistic regression, SGD, and small feed-forward nets); the tree-based models (decision tree, random forest, extra-trees, gradient boosting) are heavier and opt-in with `tracer fit --trees`. This is what makes the cost reduction real: inference is CPU-bound, sub-millisecond, and free.
+The surrogate is **not another LLM** - it is a classical ML or shallow DL model. The Python API searches linear, neural, and tree-based candidates. For a lighter sweep, pass `FitConfig(skip_candidates=("dt", "rf", "et", "gbt", "xgb"))` to exclude tree models. Inference runs locally on your CPU.
 
 1. **Fit** - train a suite of candidate surrogates on your LLM's classification traces; select the best via cross-validated teacher agreement
 2. **Gate** - attach a learned acceptor that estimates, per-input, whether the surrogate will agree with the teacher
@@ -155,7 +127,7 @@ The surrogate is **not another LLM** - it is a classical ML or shallow DL model.
 | End-to-end accuracy | 96.4% |
 | **Annual savings** (10k queries/day) | **$302,850** |
 
-_Banking77 is a 77-class task; the tree models help here, so these numbers are with `tracer fit --trees`. The lightweight default (linear + MLP) is faster and enough for most tasks._
+_Banking77 is a 77-class task; these results include tree-based candidates. Candidate selection and coverage depend on your data._
 
 ## Continual learning flywheel
 
@@ -194,19 +166,23 @@ pip install tracer-llm[embeddings]   # adds sentence-transformers
 X = tracer.embed(texts)  # default: all-MiniLM-L6-v2 (384-dim)
 ```
 
-## CLI
+## Inspect traffic before fitting
+
+`tracer.scan()` groups traces by similarity and estimates the certifiable share
+using held-out bounds. Pass the embeddings that correspond to your trace rows:
 
-| Command | What it does |
-|---------|-------------|
-| `tracer demo` | Zero-setup demo on real data |
-| `tracer scan traces.jsonl --html scan.html` | Day-one read: how much traffic is certifiably routable, with a 3D map |
-| `tracer fit traces.jsonl --target 0.95` | Fit a routing policy |
-| `tracer update new_traces.jsonl` | Refit with new traces |
-| `tracer report-html` | Open the HTML report |
-| `tracer serve .tracer --port 8000` | HTTP prediction server |
-| `tracer cloud login` | Drive Tracer Cloud from the terminal: create, train, route, test, and watch tracers, at parity with the dashboard ([docs](docs/cloud.md)) |
+```python
+from pathlib import Path
+import tracer
+from tracer.scanner import scan_html
+
+scan = tracer.scan("traces.jsonl", embeddings=X, target=0.95)
+Path("scan.html").write_text(scan_html(scan), encoding="utf-8")
+```
 
-`tracer scan` is the fast, conservative first look (similarity grouping plus exact held-out bounds, no training). It needs about 1,000 traces and works best around 5,000; below 1,000 it asks you to collect more, or pass `--force` for a best-effort floor. Embeddings are computed locally by default (sentence-transformers), or point it at your own embedding service with `--embed-url`. `tracer fit` then trains the real router and certifies more of the same traffic. The HTML report includes an interactive 3D map of your embedding space with a verdict/label colour toggle. See the [CLI reference](docs/cli.md) for every flag.
+A scan needs at least 1,000 traces; around 5,000 is recommended. Use `force=True`
+only for an explicitly marked thin-data estimate. It does not train a router;
+use `tracer.fit()` for training. See the [scan guide](docs/scan.md).
 
 ## What's in `.tracer/`
 
@@ -232,7 +208,8 @@ pip install tracer-llm[all]           # everything
 |---|---|
 | [Concepts](docs/concepts.md) | Pipeline internals, model zoo, parity gate |
 | [API reference](docs/api.md) | Every function, parameter, and return type |
-| [CLI reference](docs/cli.md) | `tracer fit`, `tracer serve`, `tracer demo`, and more |
+| [Scan](docs/scan.md) | Inspect traffic before training |
+| [Watch](docs/watch.md) | Record calls locally and configure generic exports |
 | [JavaScript / Node.js](docs/javascript.md) | Full integration guide for JS pipelines |
 | [Artifacts](docs/artifacts.md) | `.tracer/` directory schema |
 | [Troubleshooting](docs/troubleshooting.md) | `selected_method=null`, coverage drift, embedding-dim mismatch |
@@ -262,7 +239,7 @@ Adam Rida, arXiv 2026
 
 Adam Rida, Tracer AI, Inc., August 25, 2026
 
-[PDF in this repository](research/pricing-capability.pdf) | [Research article](https://tracerml.ai/research/pricing-capability/) | [Canonical PDF](https://tracerml.ai/research/pricing-capability/pricing-capability-paper.pdf)
+[PDF in this repository](research/pricing-capability.pdf)
 
 This repository preserves the 21-page final submission dated August 25, 2026. The paper defines Capability Alpha under controlled evaluation, develops Price-Implied Uplift, studies Spirit Aviation's selected data-and-software bid, and compares four public AI data and content agreements. The public PDF preserves the final submission's text, bookmarks, citations, and internal navigation, corrects one internal section reference, and adds descriptive document metadata. It is independent research without a peer review or journal acceptance claim.
 

SECURITY.md

@@ -20,7 +20,7 @@ Preferred: use GitHub's private vulnerability reporting via the
 [**Security → Report a vulnerability**](https://github.com/adrida/tracer/security/advisories/new)
 tab on this repository.
 
-Alternatively, email **adam@tracerml.ai** with:
+Include:
 
 - a description of the issue and the potential impact,
 - steps to reproduce or a proof of concept,

docs/api.md

@@ -478,6 +478,8 @@ class FitConfig:
     min_deploy_coverage: float = 0.05
     max_fit_labels: int = 8_000
     seed: int = 42
+    verbose: bool = True
+    skip_candidates: tuple = ()
 ```
 
 | Field | Description |
@@ -487,6 +489,8 @@ class FitConfig:
 | `min_deploy_coverage` | Minimum coverage fraction to consider a method deployable. |
 | `max_fit_labels` | Subsample to this size for efficiency on large datasets (stratified). |
 | `seed` | Random seed for reproducibility. |
+| `verbose` | Emit fitting progress to stderr. Set `False` for quiet runs. |
+| `skip_candidates` | Candidate names to exclude. Use `("dt", "rf", "et", "gbt", "xgb")` for a linear/neural sweep. An empty tuple keeps all available candidates. |
 
 **Example:**