Fold the prompts and sources plan into the decisions and delete it

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
WolfandClaude Fable 5.1 committed 2026-09-29 16:28:59 +02:00
1 parent 0458c9c172
commit 6124b00062
4 files changed
+19 -65

No files matched your search

+4 -4
View File
@@ -28,9 +28,9 @@ uv run app companies set-board lunar greenhouse:lunar # attach a board to a com
uv run app companies detach lunar # stop reading its board; the company stays
```
The seed is a hand-picked list of European tech employers, not a list of boards: a company whose careers site runs on something the app cannot read yet (Workday, SuccessFactors, Teamtailor, its own pages) is still a row, with that host and its slug there where one was found, shown under Companies as "not readable yet" with a link to its careers page, so the gap is visible and one parser at a time closes it. A row where nothing was found reads "board not found"; the "Not readable yet" filter shows both. Each row has a Set board control (Change once it has one) to attach, replace or detach its board by hand. Replacing or detaching closes the old board's open roles, and asks first when there are open roles to lose; a board is read once before it is kept, and one that lists no roles yet is kept too. Setting a board queues a pull right after, so its roles are read by the one already running or the very next one, rather than waiting for the schedule. `companies discover` reads a company's site for a link into one of the boards it knows, probes the hosts with a cheap per-slug endpoint only when no page names any host, and with `--add` sets the board of a new or existing company, or records the host it found when nothing readable was. A probe hit is a guess by name: check the roles it lists before trusting it for a common name.
The seed is a hand-picked list of European tech employers, not a list of boards: a company whose careers site runs on something the app cannot read yet (Workday, SuccessFactors, its own pages) is still a row, with that host and its slug there where one was found, shown under Companies as "not readable yet" with a link to its careers page, so the gap is visible and one parser at a time closes it. A row where nothing was found reads "board not found"; the "Not readable yet" filter shows both. Each row has a Set board control (Change once it has one) to attach, replace or detach its board by hand. Replacing or detaching closes the old board's open roles, and asks first when there are open roles to lose; a board is read once before it is kept, and one that lists no roles yet is kept too. Setting a board queues a pull right after, so its roles are read by the one already running or the very next one, rather than waiting for the schedule. `companies discover` reads a company's site for a link into one of the boards it knows, probes the hosts with a cheap per-slug endpoint only when no page names any host, and with `--add` sets the board of a new or existing company, or records the host it found when nothing readable was. A probe hit is a guess by name: check the roles it lists before trusting it for a common name.
A Jobindex query is its own syntax: words are OR, `"a b"` is a phrase, `+word` is required; `--area 1` is Region Hovedstaden. An Adzuna search needs a free key from developer.adzuna.com in `ADZUNA_APP_ID` and `ADZUNA_APP_KEY`. `searches add` runs the search once and saves it only if it finds something. Switching a board or search off closes its open roles, and asks first when there are open roles to lose; switching it back on, or saving a search, queues a pull right after, so the ones it still lists reopen without waiting for the schedule. The `embeddings` extra is what `fit` needs, `agent` is for `extract` on a model, `passkeys` for the Account tab's passkeys.
A Jobindex query is its own syntax: words are OR, `"a b"` is a phrase, `+word` is required; `--area 1` is Region Hovedstaden. A Platsbanken query is free text and `--region` the id of a län (`CaRE_1nn_cSU` is Skåne). An Adzuna search needs a free key from developer.adzuna.com in `ADZUNA_APP_ID` and `ADZUNA_APP_KEY`. `searches add` runs the search once and saves it only if it finds something. Switching a board or search off closes its open roles, and asks first when there are open roles to lose; switching it back on, or saving a search, queues a pull right after, so the ones it still lists reopen without waiting for the schedule. The `embeddings` extra is what `fit` needs, `agent` is for `extract` on a model, `passkeys` for the Account tab's passkeys.
## The tabs
@@ -45,8 +45,8 @@ The cog opens `/settings`: a rail of pages on the left, the page beside it, stic
| | |
|---|---|
| **Search agents** | a card per agent, newest first: name, an On/Off switch, what it looks for, and its weights. Edit turns the card into the form in place (name, intent, weights, require/any/prefer gates behind an Advanced disclosure); New agent puts a blank card on top. Saving or switching on rescores; deleting one takes its votes, liked companies and scores with it |
| **Sources** | one page showing one section at a time, picked in the rail or by the URL fragment: job boards (queries on Jobindex or Adzuna: try, save, edit, remove), company boards (every company, its board or the host it cannot be read from, its open roles and its affinity for the picked agent, following a company, setting or changing a company's board) and runs (Run the pull now, what is running, the schedule, and the Problems log) |
| **Search agents** | a card per agent, newest first: name, an On/Off switch, its prompts, its rules in words, and its weights. Edit turns the card into the form in place (name, prompts as rows, a Where block for the location rules, the other require/any/prefer rules as rows, weights); New agent puts a blank card on top. Saving or switching on rescores; deleting one takes its votes, liked companies and scores with it |
| **Sources** | one page showing one section at a time, picked in the rail or by the URL fragment: job boards (queries on Jobindex, Adzuna or Platsbanken: new, try, save, edit, remove), company boards (every company, its board or the host it cannot be read from, its open roles and its affinity for the picked agent, following a company, setting or changing a company's board) and runs (Run the pull now, what is running, the schedule, and the Problems log) |
| **Account** | the password, sessions and passkeys. Open on loopback, locked on anything else |
Likes, hidden companies and votes belong to a search agent, not to the account: two agents rank the same roles differently, and one may hide a company the other favours. An agent also learns from votes: its `taste` weight scores a role by how close it is to the roles the agent liked minus the ones it passed.
+12 -2
View File
@@ -64,6 +64,8 @@ What was decided for roledesk and the one reason for each. The longer reasoning
**Jobindex and Adzuna, not Jobnet or Jooble.** Jobindex, Denmark's largest board, has an RSS twin for every search page, with phrase and required-word syntax and a region id; no key. Adzuna has a documented API with a free key for the UK and most of the EU, but no Denmark. Jobnet's search endpoint answers 401 outside its own site's session, and Jooble gives a key only on a manual application and answered a Cloudflare challenge. LinkedIn and Indeed have no public search API.
**Platsbanken is the third search provider, for Sweden.** The JobTech API (`jobsearch.api.jobtechdev.se/search`) needs no key, states a total, so completeness follows Adzuna's rule, and filters by the taxonomy id of a län (`PLATSBANKEN_REGIONS`; Skåne is `CaRE_1nn_cSU`). It refuses an offset above 2000, which the page limit never reaches. The ads carry no usable remote field, so `remote` is read off the headline. Free text ranks by all words rather than requiring them; a quoted phrase narrows it.
**A search closes a role only when it listed everything.** A search result is not a complete list, so a role missing from one run has not closed. An Adzuna search listed everything when it read as many distinct results as the `count` it states; a Jobindex search, whose feed states no count, when a page within its page limit came back with fewer than 20 items, counted before the parser drops any, so one malformed item does not pass for the end. Such a search closes like a board; the rest close once no search has listed them for 21 days. A Jobindex answer with no RSS channel raises instead of reading as an empty, complete search. A role two searches found belongs to the last one that listed it, so one search never closes a role the other still lists.
**Jobindex ads are read from the feed, not followed to the employer.** Each item links to Jobindex's own page, and its `/c?t=` redirect leads to the employer's site or ATS. Following it per role would count as a click in Jobindex's statistics and costs a request per role, so discovering a company's ATS board from a search result is left for later.
@@ -90,6 +92,8 @@ What was decided for roledesk and the one reason for each. The longer reasoning
**Workable and SmartRecruiters are read to the end, and a board closes roles only when it read the total it states.** Workable answers 10 roles a page with a `nextPage` token and SmartRecruiters at most 100 a page by `offset`, and both parsers read page one only, so the settle took page one for the whole board and closed what fell off it: Delivery Hero stated 980 roles and 100 were open. `_paged` follows the pages 0.5 s apart, up to 100 pages, and the plugin stamps `ats:complete` only when the distinct ids read equal `total` or `totalFound`. The count is taken on the raw results, so a row the parser drops does not block closure, and on distinct ids, so a role repeated by a shifted offset does not fake completeness. A 429 after page one ends the read: the roles read are stored and nothing closes, because a partial list is no evidence that the rest closed. A 429 on page one is a failure like any other. The other five hosts answer with the whole board and are complete whenever they parse.
**Teamtailor is read from the career site's `jobs.rss`, and a slug with a dot is the site's own host.** The official API needs a key per company; the feed needs none and carries title, link, guid, `pubDate`, the description, `remoteStatus` and locations, department and role in the `tt:` namespace. `teamtailor:acme` reads `acme.teamtailor.com` and `teamtailor:careers.acme.com` that host, since most career sites run on the company's domain. `_allowed_host` allows exactly that host, redirects included, and a slug must be a DNS name whose last label is not a number; beyond that a target may name any host that resolves, the same trust as any board the owner adds. The feed states no total, so it is read by `per_page=50` and `offset` to an empty page, and a page with nothing new ends the read as incomplete. 23 of the 32 seed companies answered on their `careers_url` host on 2026-09-29; the rest list a marketing site there.
**A board that fails on every fetch for 21 days closes its roles.** A board whose fetch raised was only logged, so a company that moved ATS kept its roles open for good behind a 404. The `ats` plugin now records `ats:failing:<target>` in `state` with the time of the first failure in a row and the latest reason, and a fetch that answers removes it. Once the first failure is `STALE_DAYS` old, the same window a search role gets, the settle closes the board's roles; the next answer reopens what it lists through `upsert_role`, as for a board switched back on. The record is plugin state rather than a column because the plugin only sees `self.state`. `/api/companies` returns it as `failing_since` and `failing_reason`, the Companies list shows "not answering since", and `app companies check` prints it beside its live result.
**`pull` is a job that starts the cascade, on a default schedule of every 6h.** A schedule enqueues a job kind and a cascade is started by one, so the `pull` job only asks for the chain; declared beside it in `app/jobs/cascade.py`, the schedule is a starting point that an edit under Runs overrides for good. `pull` is not also a task, which would draw two buttons under Runs.
@@ -98,13 +102,15 @@ What was decided for roledesk and the one reason for each. The longer reasoning
**Scoring is per search agent.** A role is scored as `(uid, agent) -> score`, because a role is only good for a given search. Each gate has a mode: `require` becomes a SQL `WHERE`, `prefer` becomes a weighted term in the score. Gated roles keep their row with a reason. `companies.affinity = 2` skips the gates and floors the score, `-1` mutes.
**`fit` is the cosine between a role and the agent's intent, mapped to a level by constants calibrated per embedding model: `clip((cos - lo) / (hi - lo), 0, 1)`.** `(cos + 1) / 2` spanned only about 0.87 to 0.95 on multilingual-e5-small, so a prefer gate at 0.2 outweighed all of fit. Min-max across the roles an agent scored in the run fixed the spread but made fit a rank: the best role of a poor set got 1, a role's fit and the 0.9 favourite floor's meaning drifted from run to run, and the `limits` bars that bound the paid stages compared an absolute number with a relative one. The constants are `CALIBRATION` in `app/config.py`, keyed by model name, and an entry under `embed.calibration` replaces a model's built-in one; keyed by model, a change of `embed.model` cannot carry another geometry's constants along. A model with none falls back to min-max per run, with gated roles left out of the range, and the log warns once per run. `taste` is mapped the same way with its own pair. The starter agents' prefer weights are 0.05.
**An agent is the group: it holds several prompts, and `fit` is the best prompt's.** A hunt spans several kinds of role (AI and data leadership, customer-facing technical leadership, AI research), and one blended paragraph ranks a role by its distance to the blend. Each prompt is a named text in `agent_prompts` (migration 14, which moved every non-empty `agents.intent` into a prompt named after the agent and dropped the intent columns), embedded on its own and cached under sha1 of model and text, so an edit re-embeds one prompt. A role's fit is the maximum over the prompts of the calibrated cosine, the first prompt winning a tie, and `scores.prompt` names the winner. Votes, liked companies, gates, weights, limits and `taste` stay per agent, so a vote counts for every prompt; a market watch is a second agent with its own. No third level above the agent was added. `POST /api/agents` still takes `intent` when `prompts` is absent. On the live data of 2026-09-29 the embedder separates the three kinds of role but not seniority: an individual contributor's posting on the same subject ranks beside a head's, so seniority has to come from `extract` and a prefer gate, or from votes.
**`fit` is the cosine between a role and a prompt of the agent, mapped to a level by constants calibrated per embedding model: `clip((cos - lo) / (hi - lo), 0, 1)`.** `(cos + 1) / 2` spanned only about 0.87 to 0.95 on multilingual-e5-small, so a prefer gate at 0.2 outweighed all of fit. Min-max across the roles an agent scored in the run fixed the spread but made fit a rank: the best role of a poor set got 1, a role's fit and the 0.9 favourite floor's meaning drifted from run to run, and the `limits` bars that bound the paid stages compared an absolute number with a relative one. The constants are `CALIBRATION` in `app/config.py`, keyed by model name, and an entry under `embed.calibration` replaces a model's built-in one; keyed by model, a change of `embed.model` cannot carry another geometry's constants along. A model with none falls back to min-max per run, with gated roles left out of the range, and the log warns once per run. `taste` is mapped the same way with its own pair. The starter agents' prefer weights are 0.05.
**multilingual-e5-small's constants are fit 0.75 to 0.88 and taste -0.14 to 0.19, measured on a copy of the live database.** Over 16,841 open roles and five different intents the raw fit cosine pooled to p1 0.7528, p50 0.7989, p99 0.8528, p99.5 0.8595, p99.9 0.8711 and max 0.9031; per intent p1 ranged 0.7456 to 0.7700 and p99.9 0.8413 to 0.8773. `hi` is above every intent's p99.9, so about 5 of the "Copenhagen engineering" agent's 4,156 ungated roles clip to 1; at 0.86 (p99.5) 75 would, and lose their order where it matters most. The span 0.13 is close to the 0.145 min-max span it replaces, so a prefer weight keeps about its old size against fit. The copy had no votes, so taste comes from synthetic ones, 30 liked and 30 passed roles for each of three intents (pooled p1 -0.1404, p50 0.0429, p99.9 0.1924), and should be re-measured once real votes exist.
**The default bars are 0.55 for extract and 0.65 for summarise.** On the same data, the Copenhagen agent's ungated roles clearing each bar, min-max then calibrated, were: 0.3: 3,467 and 3,520; 0.4: 1,837 and 2,090; 0.5: 519 and 728; 0.55: 200 and 307; 0.6: 56 and 111; 0.65: 15 and 35. So 0.55 sends about 300 roles to extract and 0.65 about 35 to summarise, which its top 30 trims; the top-N backstops (500 and 30) stay for an agent whose bar admits more. The old defaults, 0.3 and 0.5, admit 3,520 and 728 on the calibrated scale, where only the top N would stop them. An agent keeps the limits stored with it, so one saved under the old defaults keeps 0.3 and 0.5 until it is edited: a migration cannot tell a stored default from a choice.
**An agent without an intent feeds neither model stage.** Its scores have no fit term, so they order roles by recency, affinity and prefer gates, and a fresh role of any kind clears a bar. `Store._top_scope` leaves such an agent out, and each score run raises one `score.no_intent` notice naming the enabled agents without an intent. The agent still ranks its own list.
**An agent without a prompt that has text feeds neither model stage.** Its scores have no fit term, so they order roles by recency, affinity and prefer gates, and a fresh role of any kind clears a bar. `Store._top_scope` leaves such an agent out, and each score run raises one `score.no_intent` notice naming the enabled agents without an intent. The agent still ranks its own list.
**The embedding backend is effectively required.** The intent is a CV or a paragraph per agent, and TF-IDF cannot relate "Kubernetes" to "container orchestration". The model is `intfloat/multilingual-e5-small`, not the English-only `all-MiniLM-L6-v2` roledesk started with: the corpus turned European, and on a sample of the live roles (all open Danish-country roles plus a random sample of the rest, language labelled by a stop-word count) against the "Copenhagen engineering" agent's intent, MiniLM separates engineering from non-engineering roles with an AUC of 0.68 overall but only 0.74 restricted to Danish-country roles, where a Danish-country engineering role beats the rest's non-engineering median only 68% of the time; multilingual-e5-small reaches an AUC of 0.70 overall and 1.00 on Danish-country roles, for about 3x the CPU time. A second multilingual candidate, `paraphrase-multilingual-MiniLM-L12-v2`, measured *worse* than plain MiniLM (AUC 0.60) and was dropped. e5 needs its own "query: " / "passage: " prefixes, which `app/jobs/embed.py` adds by matching the model name, not a separate setting.
@@ -160,6 +166,10 @@ What was decided for roledesk and the one reason for each. The longer reasoning
**Search agents are cards, edited in place.** An agent is defined by what it looks for, so the intent is the card's body and the weights a small line under it; a list of names and weights hid the part that matters. Edit turns that card into the form and New puts a blank one on top, because the new agent sorts first by id and a form at the bottom of the page was out of sight of the card it changed.
**Job boards are a list with New, edited in place like the agent cards.** The form used to sit open above the list and Edit filled it, which read as a stray form. It is a `<template>` now: Edit turns the row into the form, New puts a blank one on top, Save and Cancel close it, and one is open at a time.
**Gates are a Where block and rule rows; the JSON is a read-only view.** The location rules are the ones every agent has, so they are written in words: only roles in these countries (require), and one of country, remote or place (any), prefer hybrid. Every other gate is a row of field, mode, values and weight. A gate the Where block cannot express whole, such as a require with a weight other than 1, lands in the rows, so a load and save without edits returns the same gates.
**Affinity and votes are per agent.** A company hidden for one hunt may be a favourite for another, and a vote says what one agent should learn from, so both carry the agent id, and the Roles tab and the company list ask for one agent's. Without an agent id the API uses the default agent, the enabled one with the lowest id, so the CLI and older callers keep working.
**`taste` is the liked-minus-passed centroid, as in newsdesk.** An agent's votes become one vector, the mean of the liked roles' embeddings minus the mean of the passed ones', and a role's taste term is its cosine to that vector, calibrated like fit, weighted beside fit, recency and affinity. It is the one term an agent learns rather than is told, and it costs no model call.
+3 -2
View File
@@ -7,5 +7,6 @@ What is left after the phone rework of 2026-09-25, for whoever picks the repo up
- **Restart the server.** A server started before the rework runs the old code; on start the database migrates to schema v4 (vote, summary, article text on `roles`).
- **The live database has two agents**, "Berlin backend" and "Remote EU stretch", so Ranking edits the first and the Roles order menu lists both by name. Delete one with the CLI for a plain Best match.
- **Summarising is off** until the switch under Runs (default `summarise.enabled: false`) is used, and needs a model backend, as extract does. The Summarise button on a read page works either way once a backend is configured.
- **Ranking's gates are still a JSON box** under Advanced. A form (country list, remote require or prefer) is the next step there.
- **Votes do not train fit.** A vote only moves the rank at read time. Feeding votes into the intent vector is worth doing once there are a few hundred.
- **Fit does not read seniority.** With three prompts on the live data of 2026-09-29 an individual contributor's posting ranks beside a head's on the same subject. Switch extract on so `seniority` fills, then add a prefer gate on it, and vote.
- **Nine Teamtailor seed companies have no board**, because their `careers_url` is the marketing site: Templafy, Queue-it, Telenor, Polestar, IQM, TeamViewer, Tractive, Starship, Factorial.
- **Votes do not train fit.** A vote only moves the rank at read time. Feeding votes into the prompt vectors is worth doing once there are a few hundred.
-57
View File
@@ -1,57 +0,0 @@
# Plan: several prompts per agent, Swedish sources, Sources and gates UI
Planned 2026-09-29. Five work packages with disjoint files, built in parallel worktrees made from `main`, merged by the planner. This file is folded into `decisions.md` and deleted when the work lands.
## Why
The owner's hunt spans three kinds of role (AI and data leadership, customer-facing technical leadership, AI research and innovation). One blended intent paragraph ranks a role by its distance to the blend, so a forward deployed lead role loses to a role that is a little of everything. The sources are engineering searches on Jobindex and boards of a seed list, so 4 of 16,841 open roles are Danish leadership roles, and 7 are in Malmö, Lund or Helsingborg.
## Decisions
**An agent is the group; it holds several prompts.** Votes, liked companies, gates, weights, limits and scores stay per agent, so a vote counts for every prompt of that agent. A second agent ("Market watch 1") has its own prompts and its own votes. No third level is added.
**`fit` is the best prompt's fit.** Each prompt is embedded on its own; a role's fit is the maximum over the agent's prompts of the calibrated cosine. The name of the prompt that won is stored with the score. `taste` stays one vector per agent.
**An agent's `intent` becomes its first prompt.** The migration moves every non-empty `agents.intent` into one prompt named after the agent. "An agent without an intent" now reads "an agent with no non-empty prompt".
**Platsbanken is a third `search` provider.** The JobTech API (`https://jobsearch.api.jobtechdev.se/search`) needs no key, states a total, and filters by region concept id (Skåne län is `CaRE_1nn_cSU`). Checked live on 2026-09-29.
**Teamtailor is read from the career site's public feed.** 32 of 362 seed companies and 9 of 30 Swedish ones sit on it.
## Contracts between packages
Agent JSON, in `GET /api/agents` and `POST /api/agents`:
```json
{"id": 1, "name": "Wolf, next role", "prompts": [{"name": "AI and data leadership", "text": "VP, Head or Director of ..."}], "gates": [], "weights": {}, "limits": {}, "enabled": true, "created_at": "..."}
```
`prompts` is an ordered list of `{name, text}`; `name` is unique within the agent and non-empty, `text` may be empty. `POST` still accepts `intent` when `prompts` is absent and stores it as one prompt; `GET` no longer returns `intent`.
Search JSON, in `POST /api/searches` and `/api/searches/try`: provider `platsbanken` takes `q`, `region` (a concept id, or empty for all of Sweden) and `pages`. `plugins.search` exports `PLATSBANKEN_REGIONS: dict[str, str]` (concept id to label); the Sources template receives it as `regions`, a list of `(value, label)`.
## Work packages
| WP | Branch | Model | Owns |
|---|---|---|---|
| 1 Platsbanken | `wp1-platsbanken` | Sonnet | `plugins/search.py`, `app/jobs/sources.py`, `tests/test_search.py`, `tests/test_sources.py` |
| 2 Job boards list | `wp2-jobboards-ui` | Sonnet | `app/templates/settings/sources.html`, `app/static/sources.js` |
| 3 Teamtailor | `wp3-teamtailor` | Sonnet | `plugins/ats.py`, `app/jobs/discover.py`, `tests/test_ats.py`, `tests/test_discover.py` |
| 4 Prompts backend | `wp4-prompts` | Opus | `app/models.py`, `app/storage/schema.py`, `app/storage/store.py`, `app/jobs/score.py`, `app/web/api.py`, `app/cli.py`, `config.example.yaml`, `tests/test_score.py`, `tests/test_storage.py`, `tests/test_web.py` |
| 5 Agents UI | `wp5-agents-ui` | Opus | `app/templates/settings/agents.html`, `app/static/agents.js`, `app/static/app.css` |
**WP1.** `search_platsbanken` beside `search_jobindex` and `search_adzuna`, with paging, the completeness rule Adzuna uses (read as many as the stated total), `country` `SE`, `place` from the municipality, `remote` where the ad states it, `published_at`, description. `search_params` takes `region`.
**WP2.** The Job boards section shows the list and a New button, as the Search agents page does: the form is a `<template>`, Edit turns that row into the form in place, New puts a blank form on top, Save and Cancel close it. The form gains the Platsbanken option with a Region select fed by `regions`. No new CSS; the classes of the agent cards are reused.
**WP3.** A Teamtailor parser and host entry, read to the end, with the close-on-complete rule of the other boards; `discover` names the host for `*.teamtailor.com` and for career sites that carry Teamtailor's markers.
**WP4.** Migration 14, the store's prompt reads and writes, max-over-prompts fit, the winning prompt's name on the score, `_top_scope` and `score.no_intent` on prompts, `AgentBody.prompts`, `app agents` in the CLI, seed agents with `prompts:` in config.
**WP5.** The agent card lists its prompts; the form edits them as rows (name, text, add, remove). Gates become a rule builder in place of the JSON box: a row per rule with field, mode, values and weight, and a Location block on top that writes the usual rules (countries required, then any of: country, remote, place). Patterns come from `../news` and `../health`.
## Planner, after the merges
- Glue the two contracts: `REGION_OPTIONS` in `app/web/pages.py`, `region` in `SearchBody` and `--region` in `app searches add`.
- Data on the live database: replace the four Jobindex engineering searches with leadership and forward deployed ones, add Platsbanken searches for Skåne, create the agent "Wolf, next role" with three prompts and the location rules, switch "Copenhagen engineering" off.
- Fold this file into `decisions.md` and delete it.