Set up a local kanban board I can drive from my AI assistant. Work step by step, tell me
what you are about to do before you do it, and ask before you install anything. First
tell me which operating system you're on, and use that system's shell syntax
(PowerShell on Windows, zsh/bash on Mac and Linux). As you go, keep a file
INSTALLED.md in the vikunja folder: everything you create or change (folders, config
file and entries, every backup you make, tools, images) with versions, and the removal
steps in order. No secrets in it.

0. Security first. Before changing anything, read the steps below and tell me, in plain
   language, what this setup puts on my machine and what it can reach: each program and
   its licence, which ports it opens and to whom, where the API token is stored and what it
   can do, what (if anything) leaves my machine, and how to remove all of it afterwards.
   Include: that the token sits in plain text in the assistant's config file; that if I
   paste it into this chat it is also in the chat transcript; that whatever the assistant
   reads from the board goes to the AI provider like anything else I type; that the board
   restarts by itself whenever the container runtime starts (on Linux, Docker Engine starts
   at every boot); that on Linux the `docker` group is as good as root; and whether Docker
   Desktop's licence or admin rights apply to me. If I also want step 7, cover the strategy tool
   the same way. Flag anything that conflicts with a work laptop's policies. Then wait
   for my go.

1. Container runtime. Run `docker info --format '{{.ServerVersion}}'` (or
   `podman info`). If the command exists but can't reach the engine, it's installed but
   not running: tell me to start Docker Desktop (or `podman machine start`; the first time,
   `podman machine init`) and wait, then retry. Don't reinstall. On Linux, "permission
   denied" on /var/run/docker.sock means it is running but I'm not in the `docker` group:
   that step is mine (`sudo usermod -aG docker $USER`, log out and back in, restart you).
   If there is no runtime at all, stop and tell me my options: Docker Desktop (free for
   personal use and small companies, paid inside large ones; needs admin rights to
   install), Podman Desktop, or Rancher Desktop; on Linux, Docker Engine from Docker's own
   apt or dnf repository (docs.docker.com/engine/install). Don't assume Homebrew or
   winget. Let me install one, then continue. Also check `docker compose version`.

   Then check that port 3456 is free. If anything already answers on
   http://localhost:3456, stop and tell me, so we don't confuse it with the new board.

2. Vikunja. Vikunja is a free, open-source task board (AGPL-3.0). Make a folder called
   `vikunja` in my home directory (not in Documents or any cloud-synced folder), with `db`
   and `files` folders inside it. Generate a long random secret with a cryptographic
   generator (`openssl rand -base64 48` on Mac/Linux; .NET RandomNumberGenerator on
   Windows). Write this docker-compose.yml in that folder, as plain UTF-8 without a byte
   order mark, replacing CHANGE-ME with the secret:

   services:
     vikunja:
       image: vikunja/vikunja:2.2.0
       ports: ["127.0.0.1:3456:3456"]
       environment:
         VIKUNJA_SERVICE_PUBLICURL: http://localhost:3456
         VIKUNJA_SERVICE_JWTSECRET: CHANGE-ME
         VIKUNJA_DATABASE_PATH: /db/vikunja.db
       volumes:
         - ./db:/db
         - ./files:/app/vikunja/files
       restart: unless-stopped

   On Linux, if `id -u` isn't 1000, also add `user: "<my id -u>:<my login group id>"`
   under `image:` (the group from `getent passwd $USER`, not `id -g`). The image runs as
   user 1000 and otherwise can't write to my folders. With that line, a "mkdir /.cache:
   permission denied" in the logs is harmless.

   Run `docker compose up -d` (or `podman compose up -d`) in that folder. Wait until
   http://localhost:3456 answers. If the container exits, show me its logs. If they show a
   permission error on /db or the files folder, check that I own both folders and that the
   user: line matches me, then try again. Don't make the folders world-writable.

3. Account and token. These steps are mine, in the browser. Tell me to open
   http://localhost:3456, register an account, then go to Settings → API Tokens and create
   a token. Explain the choice: every permission lets the assistant delete as well as
   create; leaving out delete permissions is safer and enough to build boards. It still
   lets the assistant delete Kanban columns, but not the cards in them. Offer me the
   option of pasting the token straight into the config file myself instead of into this
   chat. If I do give it to you, never print it back.

4. Connect the assistant. vikunja-mcp is a free, open-source MCP server for Vikunja (MIT,
   github.com/ivantohelpyou/vikunja-mcp). It runs with uv. If uv is missing, ask me, then
   install it with the official installer from docs.astral.sh/uv, and tell me if my
   system's policy blocks it. Ask me which assistant I want to connect, and find its real
   MCP config file (for Claude Desktop: Settings → Developer → Edit Config shows it; for
   Claude Code, use `claude mcp add -s user`, which writes ~/.claude.json). If the file
   exists, back it up first, then merge this entry into its "mcpServers" object and keep
   everything else; if it doesn't exist, create {"mcpServers": {}} first. Never print the
   file's contents; it may hold other secrets. Make sure only I can read it, and any backup
   of it (they hold the token too).

   "vikunja": {
     "command": "<full path to uvx>",
     "args": ["vikunja-mcp==0.10.3"],
     "env": {
       "VIKUNJA_URL": "http://localhost:3456",
       "VIKUNJA_TOKEN": "<the token>"
     }
   }

   Use the FULL path to uvx (find it with `command -v uvx`, or `(Get-Command uvx).Source`
   on Windows; double the backslashes in JSON). Desktop apps don't see the shell's PATH,
   and a bare "uvx" fails silently. Check the result is valid JSON. Then run
   `uvx vikunja-mcp==0.10.3 --help` once, so the first launch doesn't time out downloading.

5. Verify. Tell me to fully quit the assistant, not just close its window (Mac: Cmd-Q;
   Windows: right-click the tray icon, Quit; Claude Code: /exit, then `claude --continue`
   to pick up this conversation), then reopen it and ask: "What projects do I
   have in Vikunja?" It should list the default Inbox project. If it doesn't, help me
   debug: is the container running, is the uvx path absolute and real, is the token right,
   is the config valid JSON. The assistant's MCP logs say which (for Claude Desktop:
   ~/Library/Logs/Claude on Mac, %APPDATA%\Claude\logs on Windows; for Claude Code,
   `claude mcp list` or `claude --debug`). Don't paste tokens from the logs.

6. First board: Sunday dinner, in my own kitchen. First ask me what foods I like and
   anything I don't, how many I cook for, and how much time I have on a Sunday; diets or
   allergies only if I want to say. Put the hard limits (an allergy, anything I won't
   eat) into the request itself, so nothing that breaks them gets made. What I feel like
   this week is not a limit: that belongs in step 7's strategy. Then suggest a first prompt that says how many items, what each item carries, and labels
   drawn from small fixed sets of values, for example: "Make a project called Sunday
   menus with 24 complete menus for Sunday dinner for <how many>, <diets or allergies>.
   Each menu is a starter, a main, a side and a dessert that go together. Title: a short
   name for the menu. Description: the four dishes, then one sentence on what the cook is
   in for. Labels: effort (easy / medium / hard), oven (no oven / one oven dish / two or
   more), timing (make-ahead / all on the day), diet (vegan / vegetarian / fish / meat).
   Then sort it into Kanban columns by effort." The dishes come from your memory, which
   is fine for recipes; tell me that. Build it through the vikunja tools, never through
   shell commands.

7. Optional: a strategy, next to the board. This step works with ANY tracker my
   assistant is connected to (Vikunja from the steps above, or Jira, Linear, Asana…),
   so offer it even if I skipped steps 1-5. nsnswewe is a free, open-source
   tool (MIT) that keeps a strategy on one page: positions in the five Playing to Win
   boxes, stored in a local SQLite file. Install it with uv:
   `uv tool install 'nsnswewe[mcp]==0.1.0'`. The package is nsnswewe; the commands
   it installs are `strategy` and `strategy-mcp`. Then run `strategy init` once.
   Add it to the same assistant config as a second server, using the FULL path to
   `strategy-mcp` (`command -v strategy-mcp`, or `(Get-Command strategy-mcp).Source`):

   "strategy": { "command": "<full path to strategy-mcp>" }

   After the restart, help me write three positions and adopt them. Positions are the
   situation, and they change: e.g. "Add to my strategy, box 2 where to play: fish this
   week, from the Saturday market. Then adopt it." Then show me the `triage` prompt it ships (in Claude Desktop:
   the + / attach menu; in Claude Code: the /mcp__strategy__triage command), or just
   ask: "Triage my Sunday menus project against my strategy." It keeps or parks each
   task, names the position that decided it, asks before changing anything, and never
   deletes. When I agree, mark each card with a label, keep or park, and leave every
   card in its column. Then add two Kanban views to the project, Keep and Park: the
   board's own columns in the same order, filtered to labels in keep && done = false
   (and park), each card in the column it sits in on the board. The board's own Kanban
   stays as it is.

8. Plan the cook. Suggest three menus to cook, one from each effort column (easy,
   medium, hard), from the Keep view if I did step 7; I can pick others, or more. Turn
   each into a meal plan: one project per menu, named
   "<date> · <menu name>", on Sundays in a row starting next Sunday. Ask me first what
   time food is on the table and whether I want leftovers for weekday lunches. Each
   project gets Kanban columns Shopping, Prep, Timings, Serving, and about ten tasks: one
   shopping task listing everything to buy, grouped by store section, quantities for my
   people (and the lunches), in the description; prep that can be done the day before or
   that morning; the cooking timeline working back from serving time, each title starting
   with the clock time ("4:30 PM · lamb into the oven"); and serving. Only the dishes on
   that menu.

   This is where the recipes have to be real. For each dish, look for its page in the
   Wikibooks Cookbook (https://en.wikibooks.org/wiki/Cookbook:<the name, spaces as
   underscores>, or search the cookbook for a close match; a few requests at a time, it
   refuses fast bursts). Read the page: many titles are ingredient pages, not recipes.
   Work the quantities and timings from the recipe, and put its link in the task. If a dish has no page, say so in
   the task ("no Wikibooks page: from memory, check before you cook") and never invent a
   link. If you can't reach the web, tell me, plan from memory, and flag every dish.
   Before building, tell me how many menus and tasks that comes to and which dishes have
   a page, and wait for my go. Build it through the vikunja tools.

When you're done, tell me how to stop the board (`docker compose down` in that folder),
where my data lives (the db and files folders), and how to remove everything, as
INSTALLED.md lists it: first I revoke the token in Vikunja's settings (only I can, in the
browser); then `docker compose down --rmi all`, the vikunja folder (that deletes the data,
and INSTALLED.md with it, so it goes last), the assistant config entry and any backups of
that file, and, if I want, uv and the container runtime themselves (on Linux, also leave
the `docker` group); last, restart the assistant so its servers stop. If I did step 7: `uv tool uninstall
nsnswewe`, the "strategy" config entry, and the ~/.strategy folder (my strategy's
data).