ollama: five tools over the local daemon, a benchmark that measures, and three skills

.dsh-version.json

@@ -112,6 +112,26 @@
         "Docker Desktop, for `docker_start` on Windows and macOS (launched, then its daemon polled)"
       ]
     },
+    "dsh-ollama": {
+      "version": "0.1.0-alpha.1",
+      "rows": [
+        "ollama"
+      ],
+      "rowOverrides": [],
+      "role": "Ollama as a measured surface: five `ollama_*` tools (status, run, bench, models, embed) over the machine's own daemon at 127.0.0.1:11434 - the models on disk and what is loaded now, ONE bounded inference with the daemon's own token counts and nanosecond durations, a benchmark that refuses fewer than 3 runs and reports a median with spread (cold vs warm stated at the FIRST TOKEN, because eval_duration excludes the load), A/B and num_ctx sweeps, models with pull/delete behind a confirmation that repeats the tag, and embeddings with cosine similarity - plus three bundled skills (the REST API, the metric arithmetic, the Python client) whose examples the package check parses. The loopback fence refuses an OLLAMA_HOST on another machine before any request is made (DSH_OLLAMA_ALLOW_REMOTE=1 allows one explicitly). Host-only: one row, no route, no browser half. Zero npm dependencies, no bundled engine, nothing started on its own. See packages/dsh-ollama/README.md.",
+      "uses": [
+        "@deepseek-ai/dsh-tools (the registry the five tools are registered into)",
+        "@deepseek-ai/dsh-skill (ctx.skills, resolved lazily; the three skills are also copied into $DSH_HOME/skills by both installers)",
+        "the Ollama daemon on this machine (its HTTP API at 127.0.0.1:11434; OLLAMA_HOST may move it)"
+      ],
+      "requires": [
+        "Ollama installed and its daemon RUNNING (`ollama serve`, or the desktop app) - this row starts nothing and names the command",
+        "a pulled model for ollama_run / ollama_bench, and an embedding model (e.g. nomic-embed-text) for ollama_embed"
+      ],
+      "vendors": [
+        "NOTHING is vendored, downloaded or installed: the daemon is the user's own service, and this package ships the HTTP client, one argv for `ollama --version`, and the arithmetic"
+      ]
+    },
     "dsh-media": {
       "version": "0.1.0-alpha.4",
       "rows": [

AGENTS.md

@@ -96,6 +96,13 @@ for its behaviour, `SECURITY.md` before touching credentials or the launcher, an
   then waits for the **daemon**, and a Docker tab of containers and images with
   their logs; no `exec`, no `system prune`, no free-form `run`; zero npm
   dependencies and no bundled engine),
+  `dsh-ollama` (Ollama as a measured surface: five `ollama_*` tools over the
+  machine's own daemon - status that names `ollama serve` when nothing answers,
+  one bounded inference with the daemon's token counts and nanosecond durations,
+  a benchmark that refuses fewer than 3 runs and reports a median with spread,
+  confirmed pull/delete, embeddings with cosine similarity - three skills whose
+  examples a check parses/compiles, and a loopback fence that refuses a daemon on
+  another machine before any request; host-only, zero npm dependencies),
   `dsh-research` (a run is a folder with a `passport.json` recording the user's own
   words; nine `rs_*` tools over an append-only claim and source ledger, a claim's
   numbers recorded as a validated `statistic` rather than left in the prose, a
@@ -112,10 +119,10 @@ for its behaviour, `SECURITY.md` before touching credentials or the launcher, an
 - A package may carry its OWN checks under `packages/<name>/checks/`, run with
   `npm run check` in that folder. They travel with the package (which is what
   makes them useful outside this repository) and they are ADDITIONAL to
-  `scripts/checks/`, never a replacement for it: today eight packages ship their own
+  `scripts/checks/`, never a replacement for it: today nine packages ship their own
   (`dsh-supercollider` with four checks, `dsh-research` with seven, plus
-  `dsh-diagrams`, `dsh-frontend-craft`, `dsh-proto-lab`, `dsh-ocr`, `dsh-wsl` and
-  `dsh-docker`), and the pack-wide checks still own the routes, the bundle and the
+  `dsh-diagrams`, `dsh-frontend-craft`, `dsh-proto-lab`, `dsh-ocr`, `dsh-wsl`,
+  `dsh-docker` and `dsh-ollama`), and the pack-wide checks still own the routes, the bundle and the
   manifest.
 - `scripts/` — the launchers (`run-web.*`, `run-desktop.*`), and four folders:
   `console/` (the shared console layer), `setup/` (install and uninstall, which the
@@ -133,8 +140,8 @@ for its behaviour, `SECURITY.md` before touching credentials or the launcher, an
   refused **by name**, because there is no embedded browser to select.
   `app/README.md` explains it. `check-shell.mjs` is what proves it, and it drives
   the real binary.
-- `docs/` — install, build, deploy, release, paths, compatibility, and the one plan
-  still in flight (`PLAN-ollama.md`). There is no distributer and no ship list: the distribution is this
+- `docs/` — install, build, deploy, release, paths, compatibility. There is no
+  distributer and no ship list: the distribution is this
   repository plus the binary, and the app installs the pack itself.
 - `.dsh-version.json` — the pinned harness line and the pack manifest
   (its versions must match every `package.json`; `check-node-routes.mjs` enforces

ARCHITECTURE.md

@@ -65,6 +65,7 @@ disable/replace a core row **in its own layer** — a later layer wins per row.
 | `dsh-research` | `research` | research as a folder the agent fills and the right bar shows: a run is `RUN.json` + a `passport.json` that records the user's instructions and every gate answer **verbatim**, three `rs_*` tools, four routes, and the Research tab where a **person** — never the model — answers the two frame gates (`g1-rq`, `g2-intake`). No socket, no child process, no vendored engine |
 | `dsh-ocr` | `ocr` | the pack's OCR owner: one tool, `ocr`, over `tesseract` from PATH or the OCR engine Windows itself ships (`lib/win-ocr.ps1` + `Windows.Media.Ocr`, which rasterizes a PDF page through `Windows.Data.Pdf`). Host-only — no client, no route |
 | `dsh-docker` | `docker` | Docker (or Podman) as a surface: nine `docker_*` tools over the machine's CLI, a `docker_start` that launches Docker Desktop or a podman machine and waits for its **daemon**, and a Docker tab of containers and images. argv-only and validated; no `exec`, no `system prune`, no free-form `run` |
+| `dsh-ollama` | `ollama` | Ollama as a **measured** surface: five `ollama_*` tools over the machine's own daemon — status (models on disk, what is loaded, and `ollama serve` when nothing answers), one bounded inference with the daemon's token counts and nanosecond durations, a benchmark that **refuses fewer than 3 runs** and reports a median with spread (cold vs warm stated at the first token), models with pull/delete confirmed by repeating the tag, embeddings with cosine similarity — three skills whose examples a check parses, and a **loopback fence** that refuses a daemon on another machine before any request. Host-only, no route, no browser half |
 | `dsh-proto-lab` | `proto-lab` | the **prototyping lab**: five `lab_*` tools write a run into the lab root (`~/Desktop/vncode-lab/runs/<runtime>/<slug>/` on a machine with a Desktop, `<workspace>/lab` otherwise, `DSH_PROTO_LAB_ROOT` to move it; gitignored — the bundle ships the generator, not the runs), a runtime registry (`p5js`, `openframeworks`, and a template for the third) whose every module the checks drive, a committed example library beside each skill, an offline-vendored p5.js, and verification as an explicit ladder — `t0-structure` → `t4-measure` — that always names the tier it reached |
 | `dsh-browser` | `browser` | web surface: the host fetches and renders a page in a disposable sandboxed browser (**currently disabled by the master**) |
 | `dsh-themes` | `themes` | extra palettes (Nord, Monokai, Hacker, Cyber), header controls, branding, account-menu trimming |
@@ -100,9 +101,6 @@ disable/replace a core row **in its own layer** — a later layer wins per row.
   `docs/COMPATIBILITY.md`;
 - the app: `app/README.md` (the verbs, the bridge to `scripts/run-web.*`, the app's own
   root and the harness home inside it, and the three crates);
-- work in flight, and not shipped behaviour: `docs/PLAN-ollama.md` (the
-  `dsh-ollama` design — one host-only row of `ollama_*` tools, the metric
-  arithmetic, three skills and the checks that pin them);
 - security: `SECURITY.md`;
 - **the checks are the contract**: `scripts/checks/*.mjs` pin route registrations, bundle
   wiring, budgets, the launcher contract and the credential rules. They are run by hand;

README.md

@@ -81,6 +81,7 @@ way and what it touches. The exact versions are in
 | [`dsh-ocr`](packages/dsh-ocr/README.md) | the agent can read a **picture**: one `ocr` tool over `tesseract` from PATH or — on Windows, with **nothing installed at all** — the OCR engine Windows ships, which rasterizes a PDF page itself. Names the engine, the language and the page count, refuses a language this host has no data for with the list of what it CAN read, and says every answer is a transcription |
 | [`dsh-wsl`](packages/dsh-wsl/README.md) | the **POSIX half of this pack, testable on Windows**: `wsl_status` (the launcher's table decoded from UTF-16, the default distribution marked, and with `probe` whether a distribution can actually run a check), `wsl_run` (one **argv array** in a distribution — no shell string — with a deadline, a tree kill, a 1 MB cap per stream and the exit code in the answer) and `wsl_path` (`C:\…` ⇄ `/mnt/c/…`). It exists so `run-web.sh`, `install.sh` and the `sh` branches of the checks run on the machine that writes them; the launcher's default on a Docker machine is `docker-desktop-data`, so the tools name the distribution they used |
 | [`dsh-docker`](packages/dsh-docker/README.md) | **Docker (or Podman) as a surface**: nine `docker_*` tools over the machine's own CLI — state, containers, images, inspect, logs, pull, run, lifecycle and a `docker_start` that launches **Docker Desktop** (or a `podman machine`) and waits for its **daemon** — plus a Docker tab listing containers and images with start/stop/remove, pull and run. argv-only, no shell, every removal confirmed by repeating the target, and no spelling for `exec`, `system prune` or `--privileged`. A Docker Desktop that is closed is the normal state on Windows 11: the answer says so and offers the button |
+| [`dsh-ollama`](packages/dsh-ollama/README.md) | **Ollama as a measured surface**: five `ollama_*` tools over the machine's own daemon — status (the models on disk, what is **loaded** right now, and `ollama serve` when nothing answers), **one bounded inference** with the token counts and nanosecond durations Ollama reports and nothing in the pack used to read, a **benchmark that refuses fewer than 3 runs** and reports a median with spread (cold vs warm stated at the *first token*, because a cold load never lowers tok/s), A/B and `num_ctx` sweeps, models with pull/delete confirmed by repeating the tag, embeddings with cosine similarity — plus **three skills** (the REST API, the metric arithmetic, the Python client) whose examples a check parses, and a **loopback fence** that refuses a daemon on another machine before any request. A daemon that is down is an answer, not a failure |
 | [`dsh-proto-lab`](packages/dsh-proto-lab/README.md) | a **prototyping lab** the agent fills: five `lab_*` tools write a run into the workspace's own `<workspace>/lab/<runtime>/<slug>/` — p5.js sketches a browser opens, and openFrameworks projects that are three real C++ files (`src/main.cpp`, `src/ofApp.h`, `src/ofApp.cpp`) built with your own projectGenerator and `make`. A **runtime registry** makes a third language one module and one line (Processing in Rust, Cinder), a committed example library sits beside each skill and is driven by the checks, and verification is an explicit ladder — structure, parse, compile, render, measure — whose answer always names the tier that was actually reached. The lab itself is **gitignored**: the bundle ships the generator and the examples, never the runs |
 | [`dsh-research`](packages/dsh-research/README.md) | research as a **folder you keep**: your instruction and every gate answer recorded **in your own words**, nine `rs_*` tools over an append-only claim and source ledger — `rs_write` refuses until *you* confirm the question, and a claim's quote is checked against its source. Numbers are data (`p = .000` refused), a **method record**'s screening counts cannot increase, and a **disclosure record** must be *complete* — authors, ethics, funding, conflicts, data, AI use — before the submission folder prints it beside the title page, never in the manuscript a reviewer sees. `rs_verify action=calibrate` **measures the reader**, and the tab is rendered and measured in a real browser. Eight skills, an editable tab, no socket, no child process, nothing vendored |
 | [`dsh-browser`](packages/dsh-browser/README.md) | the **Browser** tab, replacing the shipped iframe one: the page is rendered on the host in a disposable engine behind an https-only egress gate (screenshot, post-script text, measured styles) for the tab and for `browser_render` / `browser_query` / `browser_text` — **built and shipped, but turned OFF**: the master layer disables the row, so a profile loads no tab, no routes, no tools and no client bundle |