# Your kit

Your **kit** is the set of files DevLab prepares for one protocol of your organization: the client configuration, the environment of your backend and two guides. It already has everything DevLab knows (your environment's Engine URL, the protocol, the decisions Neurologyca set for your organization), so you only add what is yours: the key, and in the recording starter a public address.

## Where to find it

1. Sign in and open **Your integration** in the header. It opens on **Protocols**.
2. Choose a protocol in the list.
3. At the top of the protocol, next to **Protocol**, choose **Kit**.

The path is **Your integration › Protocols › a protocol › Kit**. Each view has its own address, so you can bookmark it.

When there is no **Kit**:

- **No active key.** If your team's key was revoked or does not exist, the protocols are shown read only ("Your organization's protocols, read only") and have no kit until your team has a key again. See [Your DevLab account](/docs/access/account/#reveal-your-teams-key).
- **Baseline.** It has no kit ("Baseline has no kit: it comes before any protocol").
- **A protocol whose context DevLab cannot resolve** ("No kit: its context is not resolved"). Ask Neurologyca if you need it.

The map of every screen is in [Where everything is](/docs/access/map/).

## The files of the kit

The Kit tab shows one tab per file, each with **Copy** and a button to download it. The kit never contains your key. Browsers drop the leading dot of a file name when they save it, so the button saves `.env.example` as `env.example` and `.npmrc` as `npmrc`, and says what to rename each one to (`.env` and `.npmrc`, in your project).

| File | Where it appears | What it is |
| --- | --- | --- |
| `neuro.config.json` | Always. | The client configuration of your protocol: pass it to defineTenantConfig(json). |
| `.env.example` | The kit in your console. | The environment of your backend, without your key: copy it to .env and fill it in. Never commit .env. |
| `.env` | The starter zip (live or recording). | The environment of your backend. The key is empty unless you downloaded the starter with «Include my key». Never commit it. |
| `.npmrc` | Always. | Maps @neurologyca to GitHub Packages and reads NODE_AUTH_TOKEN from your environment; it holds no secret. Without it, npm install answers 404 for @neurologyca/*. |
| `KIT.md` | Always. | The kit in prose: the SDK versions it is made for (with the command to check yours and the changelog), a link to the indicators your context gives you (Your integration › Protocols), start order, the notice to give the people you measure (with the model text of the Biometric Addendum and, in the recording starter, the prior written consent a deferred recording needs where the law requires it), what is pending, audiences, question options and links to the docs. |
| `AGENTS.md` | Always. | The rules and the docs index for your coding agent; paste it into your own AGENTS.md or CLAUDE.md. It is in English on purpose. |

Beside the files, the Kit tab lists what is **pending** (a decision Neurologyca has not set yet for your organization: "Ask Neurologyca") and what is **optional** (you can capture without it; for example, without a subcontext Engine applies the mechanic's own, `constellationSubcontextId`, or else the context's default). `KIT.md` carries the same information in prose, with the order to start in, what never to do (put the key in browser code, commit a credential, confuse the Engine key with the registry token), the notice to give each person you measure before any capture (with a link to the model notice and consent text, [section 14 of the Biometric Addendum](/legal/biometric-addendum/#14-model-notice-and-consent-text)), the interpretation audiences of the protocol's context and the question options of each step. It also links the indicators your context gives you, without a list: the list kept up to date is **Indicators you receive in this context**, in the protocol, in **Your integration › Protocols** ([what it shows](/docs/access/account/#your-integration)).

### The SDK versions

Under **Ways**, the Kit tab has **Versions**: the versions of `@neurologyca/capture` and `@neurologyca/capture-server` the kit is made for, the ones DevLab installs and verifies and the starters install. DevLab does not see your project, so it does not know which version you have: it compares with the publication date in the [changelog](/docs/resources/changelog/) and gives you the command to check yours, `npm ls @neurologyca/capture @neurologyca/capture-server`, with **Copy**. For **30 days** after a version is published, its row carries a chip, one per package:

- **New · date**: a compatible version. If your project uses an earlier one, update with the `npm i` command the block shows; nothing else needs to change. The link says what changes in that version.
- **Breaking · date**: a version published in those 30 days, up to the kit's, is incompatible (also when a compatible one came after it; the date is the incompatible one's). With an earlier one your project may stop working: follow the [migration guide](/docs/resources/migration/#from-027-to-043) before you update.

`KIT.md`, in the kit and in the starters, says the same under its `DevLab:` line: the versions it is made for and their date, the same command and the link to the changelog. The `doctor` script of the skill reads the same published changelog and does look at your `node_modules` ([Build with your coding agent](/docs/start/ai-agents/)).

## The variables of the `.env`

`.env.example` in the kit and the `.env` of a starter zip carry the same variables: copy `.env.example` to `.env` and fill in what is yours. The recording variables appear only where the table says so.

| Variable | Where it appears | What it is | Who fills it in |
| --- | --- | --- | --- |
| `ENGINE_BASE` | Always. | The URL of your environment's Engine, already filled in from your kit. Your backend calls it; the browser never does. | Already filled in by your kit. |
| `ENGINE_API_KEY` | Always. | Your team key, used only by your backend. It ships empty in the kit: download the starter with «Include my key», or reveal it in Your account. Never in browser code or git. | Secret. Empty in the kit. A starter downloaded with **Include my key** fills it in (the processor values need **Include my key and the processor credentials**). |
| `PROTOCOL_ID` | Always. | The id of the protocol this kit is for. | Already filled in by your kit. |
| `ROLE` | Context protocols (not Measurement). | Optional role set on each person your backend creates. The kit fills it only when Neurologyca fixed one for you, so it is often empty, and that is fine; if you set it, it must be one Engine knows. It has no effect today. | The kit fills it in only when Neurologyca fixed a value for you. |
| `NARRATIVE_LANGUAGE` | Context protocols (not Measurement). | The language of the interpretation (en or es), set on each person your backend creates. Without it, Engine writes in English. | Already filled in by your kit. |
| `PORT` | Always. | The port your backend listens on (3000 by default). | — |
| `PROCESSOR_URL` | The recording starter (deferred); in the console kit, only when your organization has the processing service. | The URL of Neurologyca's processing service for deferred captures. Empty if your organization does not have it set up. | Already filled in by your kit. |
| `PROCESSOR_API_KEY` | The recording starter (deferred); in the console kit, only when your organization has the processing service. | The key of the processing service, one pair for your whole organization. Filled only when you download the recording starter with «Include my key and the processor credentials». It stays empty if the processing service is off or not set up for your organization yet. | Secret. Empty in the kit. A starter downloaded with **Include my key** fills it in (the processor values need **Include my key and the processor credentials**). |
| `PROCESSOR_SECRET` | The recording starter (deferred); in the console kit, only when your organization has the processing service. | The secret that signs the processing service webhooks; verifying the signature is mandatory. Filled together with PROCESSOR_API_KEY, and empty in the same cases (service off or not set up yet). | Secret. Empty in the kit. A starter downloaded with **Include my key** fills it in (the processor values need **Include my key and the processor credentials**). |
| `PUBLIC_BASE_URL` | The recording starter (deferred); in the console kit, only when your organization has the processing service. | The public HTTPS origin of your backend. The processing service calls three routes there (video, token and webhook); it never calls localhost, so to test locally use a public HTTPS tunnel. | You set it. |
| `UPLOAD_URL_SECRET` | The recording starter (deferred); in the console kit, only when your organization has the processing service. | Yours alone: it signs the URLs of your videos, and differs from PROCESSOR_SECRET. Every download of the recording starter carries a new random value (a new download changes it and invalidates URLs already signed). In the console kit (.env.example) it is empty: generate a random 32-byte hex string yourself. | Secret. A new random value in every download of the recording starter. |

## `neuro.config.json`

The client configuration of your protocol: pass it to `defineTenantConfig(json)`. Your browser code reads it; it holds no secret.

| Key | Where it appears | What it is |
| --- | --- | --- |
| `engineBaseUrl` | Always. | The route of your own proxy to Engine ('/engine'), not Engine's host. The browser calls your proxy and your backend adds the key. |
| `taxonomy.contextId` | Always. | The context the capture is measured in. With Measurement it is always "measurement". |
| `taxonomy.hciId` | Context protocols that fix a target HCI. | The target HCI of the context, when the protocol fixes one. |
| `taxonomy.subcontextByMechanic` | Context protocols whose subcontext per mechanic is set. | The subcontext chosen for each mechanic, by mechanic name. Without it, Engine applies the mechanic's own or the context's default. |
| `triggerAnalysis` | Measurement only. | A key of your app, not of the SDK: your code passes it to the capture (client.capture() or captureProtocol). false because Measurement does not interpret. |
| `transcribe` | Measurement (always, as false); context protocols when transcription is on, which is the default. | Transcription: false, or { "language": "en" \| "es" } without a region. It opens the microphone too. The language is the one the person speaks: it is forced, never detected. |
| `media` | Context protocols where some step offers several questions. | The question of each step: { "<mechanic>": { "<step order>": "<mediaPid>" } }. The default is the first question not used by an earlier step. |
| `processing.language` | The recording starter only. | The language your backend sends with each deferred job (en or es); the processing service requires it. |
| `processing.transcribeSteps` | The recording starter only. | The step types the processing service transcribes. Set it to [] to turn transcription off in this starter (it ignores "transcribe"). |

## Where is the Engine URL?

Your environment's Engine URL is in **Your integration › Protocols › a protocol › Kit › `.env.example`**, on the **`ENGINE_BASE`** line. It is also the `ENGINE_BASE` line of the `.env` inside a [starter](#the-starters) zip.

The documentation never prints the value, because it is the one of your environment (test or production): the examples call it `$ENGINE`, and `ENGINE_BASE` is the same value in your backend's environment. Only your backend uses it. The browser calls your proxy, which is why `engineBaseUrl` in `neuro.config.json` is the route of your proxy (`/engine`) and not Engine's address.

If your team has no active key there is no kit, and so no `.env.example`: see [where to find it](#where-to-find-it).

## Where is my key?

The kit never carries it: `ENGINE_API_KEY` is empty in `.env.example`. You have two ways to get it:

- **Reveal it** in [Your account](/account), under **Engine keys**, with your password ([Reveal your team's key](/docs/access/account/#reveal-your-teams-key)).
- **Download a starter with Include my key**: the server writes the key in the `.env` of the zip. See below.

## The starters

A starter is a small, complete project, ready to run, with your kit already inside. At the bottom of the Kit tab, **Starters** offers two:

- **On-device (real time) starter**: the page captures in the browser and your backend proxies Engine. Choose it to see the integration working end to end, and as the base of a live capture.
- **Recording starter (deferred, server-side)** (Preview): the page records and uploads, and your backend receives the notice from the processing service. Choose it only if you will process recordings on a server ([Deferred](/docs/sdk/deferred/)). If your organization does not have the processing service yet, its card says so and the starter does not start (`npm start` stops with the same message): ask your organization's admin or Neurologyca.

Choose **Download .zip**. If the download does not start, press it again (the page says so after a few seconds). The playground has the same download in **Playground › SDK and API**, without your key.

### What the zip contains

At its root:

| File | What it is |
| --- | --- |
| `neuro.config.json` | The client configuration of your protocol, the same file as in your kit. |
| `.env` | The environment of your backend. The key is empty unless you chose **Include my key**. |
| `.npmrc` | Points the `@neurologyca` packages at the private registry and reads the token from `NODE_AUTH_TOKEN`; it never contains the token. |
| `.gitignore` | Keeps `.env`, `node_modules` and local files out of git. |
| `KIT.md` | The kit in prose, the same file as in your kit. |
| `AGENTS.md` | The rules and the docs index for your coding agent, the same file as in your kit. |
| `README.md` | The starter's own guide: requirements, the three commands and what each file of the code does. |

Plus the starter's own code: a small server, the page and the modules the playground runs. The zip of the recording starter also has the scripts to simulate the notice.

### Run it

You need **Node.js 20.6 or later** (the starters use `node --env-file`) and the registry token Neurologyca gives you with your invitation in `NODE_AUTH_TOKEN` (it is not your Engine key; see [Install](/docs/start/install/)). Without **Include my key**, first put your key in `.env` (`ENGINE_API_KEY`; [where](#where-is-my-key)).

```bash
export NODE_AUTH_TOKEN=...   # PowerShell: $env:NODE_AUTH_TOKEN="..."
npm install && npm start
```

Then open `http://127.0.0.1:3000` (the `PORT` variable changes it). If `npm start` stops with `bad option: --env-file`, your Node is older than 20.6. If it stops with `Missing in .env: …`, it names each missing variable and where it comes from. Two starters can run at once on different `PORT`s.

`npm test` checks the start in Chrome with a synthetic video as the camera (no face, so in the on-device starter it passes once the start reaches the face check; its README says how to check up to the capture with a video of yours), and deletes the test person in Engine. Without your key in `.env` (or, in the deferred starter, without the processing service) that check is skipped and says why; the rest of `npm test` still runs.

### Include my key

The key never goes in the page. To get it in the zip, tick **Include my key** and press **Download .zip**: DevLab asks for your password in a dialog, and the server writes the key in the `.env` of the zip. Cancel, or close the dialog, and nothing is sent.

- It counts as a reveal: **5 per hour per account**, shared with **Reveal** in Your account and with the processor credentials; a wrong password counts too, and every download is recorded.
- In the recording starter the option is **Include my key and the processor credentials**: it also writes `PROCESSOR_API_KEY` and `PROCESSOR_SECRET`, the pair of your whole organization (the current one, never a pending one). If the processing service is off or your organization is not set up yet, those two lines come empty with the reason. See [Deferred processing credentials](/docs/access/account/#deferred-processing-credentials).
- While your organization has not accepted the DevLab Terms, **Include my key** is disabled and says why (the same notice as Your account): you can still download the starter without the key.
- Every recording zip carries a new random `UPLOAD_URL_SECRET`: downloading again changes it and invalidates the video URLs signed with the previous one.
- `PUBLIC_BASE_URL` is yours to set: the public HTTPS address of your backend. The processing service never calls `localhost`, so to try it on your machine use a public HTTPS tunnel ([Processing service](/docs/sdk/processing/)).

> `.env` holds your key: it is in the starter's `.gitignore`. Never commit it and never put the key in browser code ([Authentication](/docs/start/authentication/)).

## If something does not work

| You see | What it means | What to do |
| --- | --- | --- |
| The download does not start, or "If the download does not start, try again" | The browser did not receive the zip | Press **Download .zip** again |
| "Wrong password: nothing was downloaded" | The password of **Include my key** is not your DevLab password | Type it again; the attempt counted toward the 5 per hour |
| "You reached the limit of 5 per hour (shared with Reveal)" | You used your 5 reveals of this hour | Wait for the hour to pass |
| "The starter is not available in this environment" (`tenant.starter_unavailable`) | This DevLab does not offer starters | Copy the files from the Kit tab instead |
| "Your team has no active key" (`tenant.team_unavailable`) | The key was rotated or revoked while you had the page open | Reload; if the team stays without a key, ask Neurologyca |
| "Your organization has not accepted the DevLab Terms yet, so the starter cannot include your key" (`legal.org_terms_required`) | Your organization's admin has not accepted the terms | Download it without the key, or ask your organization's admin to accept them |
| `npm install` fails to fetch `@neurologyca/...` | `NODE_AUTH_TOKEN` is missing or wrong | Set it in your shell ([Install](/docs/start/install/)) |
| `npm start` stops with `bad option: --env-file` | Node older than 20.6 | Update Node |
