k0-board 0.4.0 → 0.5.0

package/.claude/skills/k0-links/hooks/links.js

@@ -0,0 +1,128 @@
+// ── What a reply points at ────────────────────────────────────────────────────
+// Claude's replies are full of places — "open localhost:4321/projects/furniture/", "the photos are
+// in docs/projects/sideboard-140/", "it goes live on alessioragni.com/projects/furniture/" — and in
+// the terminal all of it is dead text. This finds them in the reply, in the order they were said,
+// so the mod can put them in a row above the prompt where one click opens each.
+//
+// It is pure on purpose: the mod's environment has no Node, the test runner has no Claude Code,
+// and this file has to run in both. Whether a path is a folder, and whether k0 is listening, is
+// for register.js to ask.
+//
+// Not imported from web/refs.js because the mod is copied into ~/.claude/skills/, where nothing
+// of k0 is next to it. The extension list is the server's `DOC_EXT`, kept in step by a test.
+
+/** The extensions the viewer can show. Same list as `DOC_EXT` in server/files.js. */
+export const DOC = new Set([
+  '.md', '.markdown', '.mdx', '.html', '.htm', '.txt', '.rtf',
+  '.pdf', '.docx', '.doc', '.odt', '.pages',
+])
+
+/** A reply naming more than this is a listing, and a row of forty buttons is noise. */
+export const MAX_REFS = 12
+
+export const extOf = (p) => {
+  const n = p.replace(/\/+$/, '').slice(p.replace(/\/+$/, '').lastIndexOf('/') + 1)
+  const i = n.lastIndexOf('.')
+  return i > 0 ? n.slice(i).toLowerCase() : ''
+}
+
+/** Fenced blocks are code being shown, not places being pointed at. */
+const FENCE = /^\s*(```+|~~~+)[\s\S]*?^\s*\1\s*$/gm
+
+const END = `[^\\s)>\\]\`'"<]`
+/** Every way a reply writes an address: with a scheme, a local port, or a domain with a path. */
+const WEB = new RegExp(
+  [
+    `https?:\\/\\/${END}+`,
+    `(?:localhost|127\\.0\\.0\\.1|\\[::1\\]):\\d{2,5}(?:\\/${END}*)?`,
+    `(?<![\\w./-])(?:[a-z0-9-]+\\.)+[a-z]{2,}\\/${END}*`,
+  ].join('|'),
+  'gi'
+)
+/** A path: something with a slash in it, relative, absolute or from home. */
+const PATH = /(?<![\w.:/~-])(?:~\/|\/|\.{1,2}\/)?[A-Za-z0-9_.@-]+(?:\/[A-Za-z0-9_.@-]+)*\/?/g
+
+/** Punctuation stuck on the end is not part of the name: "…it is in docs/plan/." */
+const trim = (t) => t.replace(/[.,;:!?]+$/, '')
+
+/** The address a written one means: a scheme added where the reply left it out. */
+export function webUrl(written) {
+  if (/^https?:\/\//i.test(written)) return written
+  if (/^(?:localhost|127\.0\.0\.1|\[::1\])[:/]/i.test(written)) return `http://${written}`
+  return `https://${written}`
+}
+
+/**
+ * The places a reply points at, in the order it says them, each as `{ kind, written }`:
+ * `web` for an address, `path` for something on disk. Which paths are real, and what they are,
+ * is not known here.
+ */
+export function references(text) {
+  const clean = String(text ?? '').replace(FENCE, '')
+  const found = []
+  const taken = [] // the stretches already claimed by an address, so a path is not found inside one
+  for (const m of clean.matchAll(WEB)) {
+    const written = trim(m[0])
+    found.push({ i: m.index, kind: 'web', written })
+    taken.push([m.index, m.index + m[0].length])
+  }
+  for (const m of clean.matchAll(PATH)) {
+    const written = trim(m[0])
+    // A bare name counts only when it is a document: `README.md` is a place, `index` is a word.
+    if (!written.includes('/') && !DOC.has(extOf(written))) continue
+    if (taken.some(([a, b]) => m.index < b && m.index + m[0].length > a)) continue
+    if (/^\/+$/.test(written)) continue
+    found.push({ i: m.index, kind: 'path', written })
+  }
+  const seen = new Set()
+  return found
+    .sort((a, b) => a.i - b.i)
+    .filter((r) => !seen.has(r.written) && seen.add(r.written))
+    .map(({ kind, written }) => ({ kind, written }))
+}
+
+/** `written` as an absolute path, or null when it cannot be one. */
+export function absolute(written, root, home) {
+  const p = written.replace(/\/+$/, '')
+  if (p.startsWith('~/')) return home ? `${home.replace(/\/+$/, '')}/${p.slice(2)}` : null
+  if (p.startsWith('/')) return p
+  if (!root) return null
+  const parts = `${root.replace(/\/+$/, '')}/${p}`.split('/')
+  const out = []
+  for (const s of parts) {
+    if (s === '..') out.pop()
+    else if (s !== '.' && s !== '') out.push(s)
+  }
+  return '/' + out.join('/')
+}
+
+/** `abs` as a path inside `root`, or null when it is somewhere else. */
+export function inside(abs, root) {
+  const base = String(root || '').replace(/\/+$/, '')
+  return base && abs.startsWith(base + '/') ? abs.slice(base.length + 1) : null
+}
+
+/** The viewer's address for one file, the same shape the board's git mark opens. */
+export const viewerUrl = (port, root, rel) =>
+  `http://localhost:${port}/files.html?${new URLSearchParams({ repo: root, f: rel })}`
+
+/** The address of an artifact, out of whatever the Artifact tool answered. */
+export const artifactUrl = (text) =>
+  String(text ?? '').match(/https:\/\/claude\.ai\/(?:code\/)?artifact\/[A-Za-z0-9_-]+/)?.[0] ?? null
+
+/** An artifact's title, out of its page: the `<title>` the page carries, when it carries one. */
+export const titleOf = (html) => {
+  const t = String(html ?? '').match(/<title[^>]*>([^<]*)<\/title>/i)?.[1]
+  return t ? t.replace(/\s+/g, ' ').trim() || null : null
+}
+
+/** The artifacts a reply mentions, by title or by address, with where it mentions them. */
+export function artifactsIn(text, artifacts) {
+  const src = String(text ?? '')
+  const out = []
+  for (const [title, url] of artifacts) {
+    const at = [src.indexOf(title), src.indexOf(url)].filter((i) => i >= 0)
+    if (at.length) out.push({ i: Math.min(...at), title, url })
+  }
+  return out
+}

package/.claude/skills/k0-links/hooks/register.js

@@ -0,0 +1,204 @@
+// ── k0-links: what the last reply pointed at, one click away ──────────────────
+// A mod: Claude Code runs these hooks inside every session, k0 or not. They do something only
+// while k0 is running on this machine.
+//
+// At the end of each reply it reads what the reply pointed at — addresses, folders, documents,
+// the artifacts this session published — and puts them in a row just above the prompt. One plain
+// click on an entry opens it: an address in the browser, a folder in Finder, a document in k0's
+// viewer, an artifact on its claude.ai page.
+//
+// The reply itself is left exactly as Claude Code draws it. The macOS Terminal cannot open a link
+// drawn inside the text, and redrawing Claude's replies to work around that was the wrong price:
+// the row is the mod's own space, and its entries are buttons, which the terminal does not have
+// to understand — Claude Code receives the click itself (in its fullscreen mode) and the mod opens
+// the target with the system's own `open`.
+
+import {
+  DOC,
+  MAX_REFS,
+  references,
+  webUrl,
+  absolute,
+  inside,
+  extOf,
+  viewerUrl,
+  artifactUrl,
+  titleOf,
+  artifactsIn,
+} from './links.js'
+
+/** A title this short is a word, and would be found in every other reply. */
+const MIN_TITLE = 4
+/** What each kind of entry looks like in the row: the place it opens in, at a glance. */
+const ICON = { web: '🌐', folder: '📁', doc: '📄', artifact: '✦' }
+
+let port = 4319
+let root = null
+let home = null
+let on = false // whether k0 answered the last time it was asked
+const artifacts = new Map() // title → claude.ai address
+let refs = [] // what the last reply pointed at: { icon, label, target }
+
+/** @type {import('claude-code').Register} */
+export const register = (hook) => {
+  hook('session.start', async ($, e, next) => {
+    const set = await $.env.get('K0_PORT')
+    if (set && /^\d+$/.test(set)) port = Number(set)
+    home = (await $.env.get('HOME')) ?? null
+    root = await topLevel($, e.cwd)
+    return next(e)
+  })
+
+  hook('prompt.submit', ($, e, next) => {
+    if (refs.length) {
+      refs = []
+      $.ui.invalidate('ui.render')
+    }
+    return next(e)
+  })
+
+  hook('tool.call', { tool: 'Artifact' }, async ($, e, next) => {
+    const ran = await next(e)
+    try {
+      await remember($, e, ran)
+    } catch {
+      // An artifact that could not be read back is simply not in the row.
+    }
+    return ran
+  })
+
+  hook('turn.complete', ($, e, next) => {
+    if (!e.agentId) void refresh($, e.answer)
+    return next(e)
+  })
+
+  hook('ui.render', { component: 'AbovePrompt' }, ($, e, next) => {
+    if (!on || !refs.length || e.props.hasSurvey) return next(e)
+    const { Box, Button } = $.ui.resolve(e)
+    return h(
+      Box,
+      { flexWrap: 'wrap', columnGap: 3 },
+      ...refs.map((r, i) =>
+        h(Button, {
+          key: `ref-${i}`,
+          label: `${r.icon} ${r.label}`,
+          plain: true,
+          onPress: () => void launch($, r.target),
+        })
+      )
+    )
+  })
+}
+
+/** The repository the session is in, as k0 knows it: git's top level, else the folder itself. */
+async function topLevel($, cwd) {
+  try {
+    const { exitCode, stdout } = await $.process.run(['git', 'rev-parse', '--show-toplevel'], { cwd })
+    if (exitCode === 0 && stdout.trim()) return stdout.trim()
+  } catch {
+    // No git on this machine: the folder is the best guess there is.
+  }
+  return cwd
+}
+
+/**
+ * Asks k0 which of `paths` are documents its viewer has in this repository. Null when k0 is not
+ * answering; `known: false` when it answers but has never seen this folder.
+ */
+async function exist($, paths) {
+  try {
+    const r = await $.http.fetch(`http://localhost:${port}/api/files/exist`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ repo: root, paths }),
+    })
+    if (r.ok) return { known: true, paths: new Set(JSON.parse(r.text).paths ?? []) }
+    // k0's own refusal for a folder it has never opened a session in — anything else on this port
+    // is not k0, and is treated as k0 not running.
+    if (r.status === 400 && /repository/i.test(r.text)) return { known: false, paths: new Set() }
+  } catch {
+    // Nobody listening: k0 is off.
+  }
+  return null
+}
+
+/** What a folder or file on disk is, or null when there is nothing there. */
+async function kindOf($, abs) {
+  try {
+    return (await $.fs.stat(abs)).kind
+  } catch {
+    return null
+  }
+}
+
+/** Reads the reply that just ended, and redraws the row once, at the end. */
+async function refresh($, answer) {
+  const found = references(answer)
+  const docs = []
+  const out = []
+  for (const r of found) {
+    if (r.kind === 'web') {
+      out.push({ icon: ICON.web, label: r.written, target: webUrl(r.written) })
+      continue
+    }
+    const abs = absolute(r.written, root, home)
+    if (!abs) continue
+    const kind = await kindOf($, abs)
+    // An address written without its scheme, the domain on disk nowhere: still an address.
+    if (!kind && /^(?:[a-z0-9-]+\.)+[a-z]{2,}\//i.test(r.written)) {
+      out.push({ icon: ICON.web, label: r.written, target: webUrl(r.written) })
+    } else if (kind === 'dir') {
+      out.push({ icon: ICON.folder, label: r.written, target: abs })
+    } else if (kind === 'file' && DOC.has(extOf(abs))) {
+      const rel = inside(abs, root)
+      if (rel) {
+        const entry = { icon: ICON.doc, label: r.written, target: null, rel }
+        docs.push(entry)
+        out.push(entry)
+      }
+    }
+    // Code and every other file: not a place to go, it stays out of the row.
+  }
+
+  const got = await exist($, docs.map((d) => d.rel))
+  on = Boolean(got)
+  for (const d of docs) if (got?.known && got.paths.has(d.rel)) d.target = viewerUrl(port, root, d.rel)
+
+  const mentioned = artifactsIn(answer, artifacts).map((a) => ({ icon: ICON.artifact, label: a.title, target: a.url }))
+  const seen = new Set()
+  refs = [...out.filter((r) => r.target), ...mentioned]
+    .filter((r) => !seen.has(r.target) && seen.add(r.target))
+    .slice(0, MAX_REFS)
+  $.ui.invalidate('ui.render')
+}
+
+/** Opens a target the way the system opens it: a browser tab, a Finder window. */
+async function launch($, target) {
+  for (const argv of [['open', target], ['xdg-open', target]]) {
+    try {
+      const { exitCode } = await $.process.run(argv)
+      if (exitCode === 0) return
+    } catch {
+      // Not this system's opener: try the next one.
+    }
+  }
+  $.ui.toast(`Could not open ${target}`)
+}
+
+/** A published artifact, kept under its title so the reply that mentions it can list it. */
+async function remember($, e, ran) {
+  if (ran.deny !== undefined || ran.isError) return
+  if ((e.action ?? 'publish') !== 'publish' || e.asset) return
+  const url = artifactUrl(ran.text) ?? artifactUrl(e.url)
+  if (!url) return
+  let title = null
+  if (typeof e.file_path === 'string' && /\.html?$/i.test(e.file_path)) {
+    title = titleOf(await $.fs.read(e.file_path))
+  }
+  title ??= e.title ?? null
+  if (!title && typeof e.file_path === 'string') title = e.file_path.split('/').pop().replace(/\.[^.]+$/, '')
+  if (!title || title.length < MIN_TITLE) return
+  // A redeploy can rename the page: the address keeps one title, the newest.
+  for (const [t, u] of artifacts) if (u === url) artifacts.delete(t)
+  artifacts.set(title, url)
+}

package/.claude/skills/k0-next/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: k0-next
+description: Answers "what do I do now" from what the k0 server already knows — the order the stories are in, the star, the dependencies that are not done yet, what is open, and what has been sitting in Review waiting for somebody to look at it. One call and a sentence, not a round of reasoning. Use this skill when the user types "/k0-next" or says "what should I do now", "what's next", "pick the next story", "what do I pick up", "cosa faccio adesso", "cosa mi conviene fare", "qual è la prossima storia", "da dove riparto". Do not use it to decide priority — that is /k0-order — to discuss a story, or to guess an order the server has not been told.
+---
+
+# /k0-next
+
+One question, one answer: what to pick up in this repository right now.
+
+```bash
+PORT="${K0_PORT:-4319}"
+REPO="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"; REPO="${REPO%/.git}"
+[ -d "$REPO" ] || REPO="$(git rev-parse --show-toplevel 2>/dev/null)"
+curl -sS --max-time 30 --get --data-urlencode "repo=$REPO" \
+  "http://127.0.0.1:$PORT/api/backlog/next"
+```
+
+`127.0.0.1`, not `k0.localhost`: browsers resolve that name by themselves, `curl` does not.
+`--get --data-urlencode`, not `?repo=$REPO`: a repository path with a space in it makes `curl`
+refuse the address outright, and one with a `#` in it quietly sends half.
+`$SCRATCH` is the session's scratch directory; nothing is written outside it. `REPO` is the
+repository the stories are filed under — the main one, even when this session sits in a
+subdirectory of it or inside a worktree, which is why it is not `$PWD`.
+
+If `curl` cannot connect, the k0 server is not running: say so (`k0-board start`, or the tray
+icon → *Restart*) and **stop**. If the answer is `{"enabled": false}`, say in one line that the
+backlog is switched off in k0's settings and **stop**. If `REPO` is empty — or the answer carries
+an `error` and no story at all — this is not a checkout and the server refused the question: say
+so, ask once which repository he means, and take the path he gives. That is not an empty backlog
+and must never be reported as one.
+
+**If the answer names no story at all**, do not report an empty backlog yet. Ask the board
+itself, once, and let it say which of the two things is true:
+
+```bash
+curl -sS --max-time 30 --get --data-urlencode "repo=$REPO" \
+  "http://127.0.0.1:$PORT/api/backlog" -o "$SCRATCH/k0-backlog.json"
+```
+
+`enabled` false → the feature is off, and that is what you say. An `error` and no `stories` key →
+the repository was not recognised, which is the answer above and not an empty board. Stories
+present but none ready → say what is blocking them. `stories: []` → say the board is empty for
+this repository.
+"Nothing to pick up" and "the backlog is switched off" look identical from `/next` alone, and
+telling a man his backlog is empty when it is merely off is the one answer worse than no answer.
+
+The answer is otherwise the story to pick up and **why** — the server has already weighed the
+order, the star, the dependencies, how long something has been in `Review`. That reasoning is
+done. Do not redo it, do not second-guess it, and do not fetch the whole board to check its work.
+
+## What to say
+
+Three lines at most, in the user's language:
+
+> **K42 · 1.12 — Fix the API when the token expires.** Starred, nothing blocking it, and it is
+> the first thing in the order.
+>
+> K37 has been in Review for four days.
+
+The key, the title, the one sentence of why, and — only when the answer carries
+one — the thing that has been waiting. **Then stop.** No question, no box, no "shall I start it".
+He asked what to do next and he has been told; what he does with that is his next message.
+
+If that next message says to start it, this is the call:
+
+```bash
+curl -sS --max-time 30 -X POST "http://127.0.0.1:$PORT/api/backlog/story/$STORY_ID/start" \
+  -H 'content-type: application/json' -d '{"auto_send": false}'
+```
+
+That opens a Claude Code session on the story, the same way the board's button does.
+
+## Rules
+
+- **One call.** The second one happens only when `/next` came back empty, or when he asks for a
+  shortlist rather than the next thing — and then show three rows, not the board.
+- **Never ask a question here.** The answer to "what now" is an answer, not a discussion, and a
+  question box on a read-only lookup is the beat this skill exists to skip.
+- **Never invent an order.** If the server says nothing is ready — everything blocked, or the
+  backlog empty — say that plainly and say what is blocking it. Do not pick something anyway.
+- **Never start the session unasked**, and never move a state.
+- Talk to the user in his language. The keys and the state names stay as they are.

package/.claude/skills/k0-order/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: k0-order
+description: Reorders the k0 backlog from an instruction said out loud — what goes to the top, what waits on what, what is starred. Resolves the keys to stories itself, applies the change through the API and answers in one line. Use this skill when the user types "/k0-order", or says "K51 to the top", "K42 depends on K37", "star K19", "move K7 below K12", "put the login one last", "unstar K3", "K51 in cima", "K42 dipende da K37", "metti la stella su K19", "sposta K7 sotto K12", "questa prima di quella". Do not use it to decide what to work on next (that is /k0-next), to change a story's state or title (/k0-story), or to break one up (/k0-split).
+---
+
+# /k0-order <what to move, what waits on what, what to star>
+
+Priority dictated at the speed it is thought: *K51 to the top, K42 waits on K37, star K19.*
+Several instructions in one breath is the normal case, not the exception.
+
+## Procedure
+
+1. **Read the board.**
+
+   ```bash
+   PORT="${K0_PORT:-4319}"
+   REPO="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"; REPO="${REPO%/.git}"
+   [ -d "$REPO" ] || REPO="$(git rev-parse --show-toplevel 2>/dev/null)"
+   curl -sS --max-time 30 --get --data-urlencode "repo=$REPO" \
+     "http://127.0.0.1:$PORT/api/backlog" -o "$SCRATCH/k0-backlog.json"
+   ```
+
+   `127.0.0.1`, not `k0.localhost`: `curl` does not resolve that name. `--get --data-urlencode`,
+   not `?repo=$REPO`: a repository path with a space in it makes `curl` refuse the address
+   outright, and one with a `#` in it quietly sends half. `$SCRATCH` is the session's
+   scratch directory; nothing is written outside it. `REPO` is the repository the stories are
+   filed under — the main one, even when this session sits in a subdirectory of it or inside a
+   worktree, which is why it is not `$PWD`.
+
+   - `curl` cannot connect → the server is not running. Say so (`k0-board start`, or the tray
+     icon → *Restart*) and **stop**.
+   - `{"enabled": false}` → say in one line that the backlog is switched off in k0's settings and
+     **stop**.
+   - `REPO` empty → this is not a git repository. Ask once which repository this belongs to.
+
+   That one file has every key, title, state, star, `sort_hint` and dependency you need.
+   Do not ask the user for any of it and do not fetch it twice.
+
+2. **Resolve what he named.** `K42` is a key; *the login one* is a title. Keys are per
+   repository, so `K42` here is not `K42` next door — resolve inside the repository you are in.
+   If a key is not on this board, say so and ask which repository; do not guess at another one.
+   If a description matches two stories, ask which. Never act on a key you have not seen in the
+   file.
+
+3. **Work out every change before sending one.** The list is small, so hold it whole: a
+   contradiction inside one breath — *K7 to the top, and K7 after K12* — is caught now, and
+   asked about now, not half-applied.
+
+4. **Apply it.**
+
+   **Position.** Stories are ordered by `sort_hint` ascending, ties broken by age — the older
+   story wins a tie. So *to the top* is not a fixed number, it is **ten below the lowest
+   `sort_hint` on the board**, and *to the bottom* is ten above the highest. Both numbers are in
+   the file you read in step 1; work them out from it every time:
+
+   ```bash
+   # lowest sort_hint on the board is 20 → to the top is 10
+   curl -sS --max-time 30 -X PATCH "http://127.0.0.1:$PORT/api/backlog/story/$ID" \
+     -H 'content-type: application/json' -d '{"sort_hint": 10}'
+   ```
+
+   Never send a hardcoded number, and never the one in that example. Send `-1` twice and the
+   second story ties with the first, the tie goes to whichever is older, and the story he asked
+   to put on top lands second — while the receipt line says it went to the top. He has no way to
+   see that until he reloads the board.
+
+   To put one *between* two neighbours that have no room between them, renumber: take the
+   affected list in the order he now wants it, hand out 10, 20, 30 … and `PATCH` only the rows
+   whose number actually changed. Renumbering the ones that did not move is churn the mirror
+   then has to write out again.
+
+   **Star.**
+
+   ```bash
+   curl -sS --max-time 30 -X PATCH "http://127.0.0.1:$PORT/api/backlog/story/$ID" \
+     -H 'content-type: application/json' -d '{"starred": true}'
+   ```
+
+   **Dependency.** `story_id` is the one that waits, `depends_on` is the one it waits for — say
+   the sentence out loud before you fill it in, because inverted dependencies are silent and
+   only turn up weeks later.
+
+   ```bash
+   curl -sS --max-time 30 -X POST "http://127.0.0.1:$PORT/api/backlog/dependency" \
+     -H 'content-type: application/json' -d '{"story_id": 42, "depends_on": 37}'
+   ```
+
+   Removing one is the same call with `"remove": true`.
+
+5. **Say what you did, in one line.** In his language, keys and what changed, nothing else:
+
+   > K51 to the top, K42 now waits on K37, star on K19.
+
+   No table, no recap of the board, no offer to reorder anything else. He is mid-thought and the
+   line is a receipt, not a report.
+
+## Dependencies warn, they never block
+
+A dependency marks a story on the board and nothing more. It does not stop it being started,
+planned or finished, and this skill never refuses an instruction because of one. When a change
+leaves a story waiting on something unfinished, that goes in the same receipt line as a clause:
+
+> K42 now waits on K37, which is still Planned — a note, not a lock.
+
+Two things are worth stopping for, and both are mistakes rather than priorities:
+
+- **a story depending on itself** — say so and do not send it;
+- **a loop** — K42 waits on K37, which already waits on K42. You can see it in the `deps` of the
+  file you read in step 1. Name the loop, do not send the call, and let him choose which edge he
+  actually meant.
+
+## Rules
+
+- **Only order, star and dependencies.** Not state, not title, not epic, not deletion. If he asks
+  for one of those in the same breath, do the ordering, say which part you left alone and which
+  skill does it, and stop.
+- **Never invent a key.** `key_num` is the server's to allocate. A key that is not on the board
+  is a mistake to report, not a story to create.
+- **Never ask what the API can tell you.** The current order, who is starred, what already
+  depends on what, whether a story is blocked — it is all in step 1's answer.
+- **Talk in the language the user speaks.**
+- **No files outside the scratch directory**, and never write into `.k0/` by hand: the server
+  mirrors the change there on its own.