DIN

Docs

Install DIN

The free build is one download: fifteen programs, the plugin and an installer. No account, no signup and no card. This page covers release 1.0.42.

Which platforms

The one line

curl -fsSL https://dinctrl.com/install | sh

That is steps 1 to 3 below, done for you, and it checks before it runs anything:

1. It refuses anything but Linux x86-64 by name, and a Mac unless the release carries a macOS build (on a Mac: "DIN for macOS is available on request: this release has no macOS download"). 2. It reads SHA256SUMS from the download page's own directory. The archive's name, and so the version, comes from that list. 3. It checks SHA256SUMS.minisig against the key printed below, which is written into the script and never fetched: with minisign when it is installed, otherwise with OpenSSL 3 or later, which most Linux machines already have. With neither, it stops and installs nothing: it prints "SIGNATURE NOT CHECKED, so nothing was installed" and names the two ways out, install minisign or run it on a machine with OpenSSL 3 or later. 4. It downloads the archive and stops unless its SHA-256 matches SHA256SUMS. 5. It unpacks the archive into a temporary directory and runs its install.sh, at your terminal, so the agent question below is still asked.

Any mismatch: it deletes the temporary directory, installs nothing, and exits non-zero. It never uses sudo. You can read it first: open dinctrl.com/install in a browser.

Every installer option works from the one line, after sh -s --:

curl -fsSL https://dinctrl.com/install | sh -s -- --agent cursor
curl -fsSL https://dinctrl.com/install | sh -s -- --prefix /opt/din --no-start
curl -fsSL https://dinctrl.com/install | sh -s -- --path

--path is the one-liner's own option: it adds export PATH="<prefix>/bin:$PATH" to your shell's profile (~/.bashrc, ~/.zshrc or ~/.profile). Without it, nothing is edited and the line is printed for you to run.

Or do it by hand, reading the archive before you run anything:

1. Download

Everything is on the download page. These are the release files:

From a shell:

curl -fsSLO https://dinctrl.com/download/din-1.0.42-linux-x86_64.tar.gz
curl -fsSLO https://dinctrl.com/download/SHA256SUMS
curl -fsSLO https://dinctrl.com/download/SHA256SUMS.minisig

2. Verify the download

Every release is signed with minisign. The public key (key id 36C9AB1B4CC4A458) is printed here, not only shipped beside the download it vouches for:

RWRYpMRMG6vJNhzPUkYbbwTX9ebqgd1rW50Rlkv+/BZ4uAPzfda0KTqK
# install minisign first: apt install minisign / brew install minisign
minisign -Vm SHA256SUMS -P RWRYpMRMG6vJNhzPUkYbbwTX9ebqgd1rW50Rlkv+/BZ4uAPzfda0KTqK
#   -> Signature and comment signature verified
#   -> Trusted comment: DIN 1.0.42 <date>  (it names the version you downloaded; check it does)
sha256sum --ignore-missing -c SHA256SUMS
#   -> din-1.0.42-linux-x86_64.tar.gz: OK

If either check fails, stop: do not run the installer. The installer does not check the signature for you. It checks only that the nine core programs and din-grade are present before it writes anything.

3. Install on Linux

tar xzf din-1.0.42-linux-x86_64.tar.gz && cd din-1.0.42
sh install.sh
export PATH="$HOME/din/bin:$PATH"
din status

din status is the check that matters. It names every program, says whether the field is up, says whether your token opens it, and tells you what to type next.

Pick your agent

DIN is for any agent: any agent runtime can read the field through its HTTP API with the field token, and a person can stamp a record. The installer wires the agents it knows. Run at a terminal, it asks which agent DIN should capture: Claude Code, Cursor, OpenCode or Codex, one or several, Gemini CLI for recall only, or 6, none: import only (ChatGPT and others, which have no live capture). Or say it up front with --agent, once per agent; --agent none is import only. With no --agent and no terminal (a script, a pipe) it picks the agent a person would have been offered, the first one it finds here (Claude Code when claude is on PATH, else Cursor, else OpenCode), and says which and why in its closing lines. With none of them here it wires none.

Pick several on the free build and each is still wired, but the field serves one AI agent: the newest, with the others set aside and kept in full. The installer says so in one line. din field activate <agent> switches which one is served; a paid plan keeps them all live together, with live capture.

To change your mind after the install, there is no need to run the installer again:

din agent list                  # which agents are wired, and which one your field serves
din agent add cursor            # wire claude-code, cursor, opencode, codex or gemini
din agent remove cursor         # unwire it; its records stay in your field

On the free build, din agent add first says what a second agent does and, at a terminal, asks before it wires anything (--yes to skip the question). With no terminal to ask at (a script, or the console's Settings page with its box unticked), it wires nothing unless you pass --yes.

The installer takes these options:

sh install.sh                      install into ~/din and bring it up
sh install.sh --agent cursor       which agent to capture (repeat for several):
                                   claude-code, cursor, opencode (live capture, paid);
                                   codex (recall; live capture, paid);
                                   gemini (recall; history by import);
                                   chatgpt, qwen, cline, grok, zep, graphiti,
                                   none (import only: nothing is wired)
sh install.sh --grade-with key     how grading runs: cli, codex, key or local
                                   (--grade-model M, --grade-url URL)
sh install.sh --prefix /opt/din    somewhere else
sh install.sh --dry-run            print every step, touch nothing
sh install.sh --no-plugin          skip the plugin: no agent is wired
sh install.sh --no-start           lay it down but do not start the field
sh install.sh --port 8093          the field's loopback port
sh install.sh --console-port 8097  the local console's loopback port
sh install.sh --schedule           also schedule the capture sweep (cron)

More than one field

New in 1.0.32. One install can hold several fields, for example one per client or per project. Each has its own store, its own token (mode 600, never printed) and its own loopback port; they share this install's programs and your plan, and each starts on first use like your main one, which is called main.

din field new work                 # ~/din/fields/work, on a free port (or --port N)
din field list                     # every field: port, records, active agent, "N of M" on your plan
din field use work                 # the default for recall, query, brief, console and import
din recall --field work "<q>"      # --field picks one field for status, console, import, recall,
                                   #   query, brief, where, dep-audit and din field start|stop|status

Your plan includes a number of fields, and din field list shows how many you have of that number. From 1.0.39 that number is enforced: past it, din field new (and din field routes --import-capture-map <file> --create, and the console's Fields control) makes nothing, says your plan, how many fields it includes and how to get more, and exits 3. Free includes 1 field, your own main, so on Free din field new refuses; on Free up to 3 people review that field. The fields you already have are never touched: an install with more than its plan includes (made before 1.0.39, or kept after a downgrade) keeps every field working, and din field list says OVER PLAN.

To have captures land in the right field, route each project to it. The plugin reads the routes at the end of each session and places that session's records into its project's field:

din field route my-repo work       # sessions in that project go to `work`
din field route --default main     # every project with no route of its own
din field routes                   # what is routed where
din field unroute my-repo

A project is matched, ignoring case, by the folder you work in (or DIN_CHANNEL), its name in DIN_PROJECT_MAP if you use one, or Claude Code's own name for the folder. With no routes at all, everything goes to your main field, as before. din status and /din status show each field and its last capture. If you kept a hand-written capture-map.json, din field routes --import-capture-map <file> shows what it would route, and --create also makes the fields it names. You can also make fields from the console: see Console settings.

Routes apply to everything that captures on this machine: the plugin's hooks and sweep, the Codex sweep, and din capture. If a route names a field whose store is not there, nothing is placed, in that field or any other. The log says why, and the run is placed on a later pass once the store is back.

A field can belong to another install on the same machine, for example a server with one install per field. Attach it by its store, then route to it. Its port and token file are recorded for din status and din field routes; the token file is never read, and nothing of that install is started or changed. An attached field counts as one of your plan's fields.

din field attach core2 --store /srv/core2/records --port 8301 --token-file /srv/core2/.din/field.token
din field route --default core2    # captures from this machine go to core2
din field detach core2             # after removing the routes to it; the store is untouched

On a server, a timer can feed one field with no capture map. Live capture needs a paid plan.

din capture --once --field=core2 --skip-headless                 # one pass
din capture install-task --field=core2 --skip-headless           # every 10 minutes

--field <name> and --field=<name> are the same flag. A project with a route of its own still goes to its route. With no capture map, the pass reads every project your din capture exclude and din capture only settings allow, and din capture off stops it. It starts from now: sessions already on disk are left alone unless you add --backlog. --skip-headless leaves out claude -p and SDK sessions, and applies to din capture only: to keep such sessions out of the plugin's hooks and sweep, exclude their folders with din capture exclude <path>. An exclusion also covers folders whose name only begins the same way, so excluding /srv/work skips /srv/work-2 too. Run either this timer or the plugin's sweep on a machine, not both, or a session is captured twice.

--skip-headless leaves out claude -p and SDK sessions, and it is off by default. It is for a box where people work and spins run beside them. On a box where all the work is headless (supervisor mode), do not turn it on: it would leave out everything. Exclude only the directories you do not want captured, for example din capture exclude ~/agent-runs.

What the installer does

How grading runs: your own inference

Nothing in the install needs an API key, and DIN never pays for, proxies or sees a model call. Three steps call a model, each on your own inference and each forecasting its cost first: din import --grade, din grade on (which grades live-captured sessions, so it needs live capture, a paid feature) and din regrade --run. None needs a spend cap; a cap you set (for example din grade on --daily-cap USD) holds, with one exception: on a model no price card covers, on a path that may bill per call (an OpenAI key, for one), a dollar cap cannot count, so it is not used and grading is held to 3 attempts a day instead. The installer asks how to grade (or say it with --grade-with cli|codex|key|local, and --grade-model M, --grade-url URL), and din setup model changes it later. There are three ways:

With more than one here, the order is the CLI (Claude Code first, then Codex), then a key, then a local model; din grade on --via cli|codex|key|local picks one. Claude Code is the path DIN's grading was measured on. The Codex, API-key and local-model paths are built and tested against stand-ins; none of them has been validated against a real vendor yet.

Where a grading call goes is set in ~/.din/plugin.env, not by your agent session's environment, because a repository's .claude/settings.json env block reaches the hooks: the proxy and CA settings (HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, NO_PROXY, SSL_CERT_FILE, SSL_CERT_DIR, CURL_CA_BUNDLE, NODE_EXTRA_CA_CERTS), ANTHROPIC_BASE_URL, CLAUDE_CODE_USE_BEDROCK and CLAUDE_CODE_USE_VERTEX, CLAUDE_CONFIG_DIR, CODEX_HOME and XDG_CONFIG_HOME; so are where capture reads (DIN_TRANSCRIPTS) and your licence file (DIN_ENTITLEMENT). The plugin installer copies the proxy, the CA, CLAUDE_CONFIG_DIR, CODEX_HOME and XDG_CONFIG_HOME from the shell it runs in (only names plugin.env does not hold yet), and din setup model copies the proxy and CA. Otherwise put one there yourself, or put DIN_TRUST_ENV=1 in plugin.env to let the environment set them.

On Codex or an OpenAI key, a level depends on the model and its reasoning effort: din grade on --effort <level> sets it (every path runs at medium otherwise), and OpenAI levels above medium need it. gpt-6-sol at medium effort reads at Reader on any plan, Free included; Analyst and up are paid. DIN picks no model for you on Codex: name one. Grading on the Gemini CLI is turned off: DIN cannot run it with its tools locked down.

A paid install also checks in with our licensing service, with its random install id: when you run din activate, at most once a day when the field or the console starts, and daily from its timer once you turn on din autostart on. Each signed check-in lasts 14 days. A free install never checks in.

Next