k0-board 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -6,6 +6,54 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.3.0]
+
+k0 could already tell you what each session was costing you in memory, and `Close` on a card was
+already how you gave it back. This version is k0 remembering to do that for you: a terminal left
+untouched all day is shut by itself, and the card it belongs to stays exactly where it was, ready
+to be picked up again. It is careful about which ones — never one that is working, never one with
+a question on screen — and it is the first thing in k0 you can change without changing k0, in a
+settings file that writes itself.
+
+### Added
+
+- **The terminals you have stopped using close themselves, and the work stays.** A session left
+  open goes on costing memory whether or not anybody is looking at it — the `claude` process, the
+  MCP servers it started, the browsers those opened — and `Close` on a card has always been the
+  cure. Now k0 remembers to do it for you: **after twelve hours with nothing happening, a yellow
+  card's terminal is shut and its memory given back**. Nothing is lost. The card stays exactly
+  where it is with the status it had, and **Resume** picks the conversation up where it was, the
+  same as it always did. Only yellow — *Your turn* — is ever touched: a card that is **working**
+  is somebody mid-thought, and a card with a **question or a plan on screen** would lose the very
+  thing it was showing you, because a dialog that is open has not been written to the transcript
+  yet. A session sitting in a **shell** is left alone too — there may be a command of yours
+  running in it, and k0 cannot see what. A window you were using an hour ago is never closed,
+  whatever the card's history says: every clock k0 has for that session is consulted and the
+  newest one wins.
+- **A card says who closed it, and the top bar says the closing is on.** Where a card used to read
+  *session closed* it now reads *closed automatically* if it was k0 that tidied it away — same
+  italic, same place, one word different. And the memory chip at the end of the top bar carries the
+  hours in lighter type: **RAM 79% · CPU 19% · closes at 8h**, with the whole sentence on hover.
+  That is where it belongs, because that is where the memory is already being talked about, and
+  something that closes your windows for you should never be a surprise. Switched off, the chip
+  says nothing rather than *0h* — which would read as "closes immediately" — and the hover says so
+  instead.
+- **Settings, in a file that is the list of them.** `~/.k0/config.json` — on Windows
+  `%LOCALAPPDATA%\k0\config.json` — written out on the first run with every setting already in it
+  at its default, so opening it is how you find out what there is to change. It sits beside the
+  board rather than inside the app, so an update cannot throw it away, and k0 picks up a change by
+  itself without anything being restarted. `closeIdleTerminalsAfterHours` is the first entry:
+  **set it to `0` and the closing above never happens**. There is no settings page on the board and
+  there is not going to be one — the board is for what changes during a working day —
+  so `k0-board doctor` prints the whole list too, with what is in force and where the file is.
+
+### Fixed
+
+- **Resuming a session no longer types the old prompt back in.** A card's prompt belongs to the
+  moment the session starts; on **Resume** the conversation had already answered it hours ago, and
+  putting it back under the cursor was at best something stale in the way — at worst it was sent,
+  because where pasting is not available k0 types it instead. Start is unchanged.
+
 ## [0.2.0]
 
 k0 could always tell you how the work stood. This version lets it tell you whether the work is
@@ -226,7 +274,9 @@ here is everything that had to change for it to be somebody else's tool as well.
 - The personal fixtures k0 grew up on. `test/clean.test.mjs` now fails the build if any of them
   come back.
 
-[Unreleased]: https://github.com/alessio-ragni/k0-board/compare/v0.1.2...HEAD
+[Unreleased]: https://github.com/alessio-ragni/k0-board/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/alessio-ragni/k0-board/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/alessio-ragni/k0-board/compare/v0.1.2...v0.2.0
 [0.1.2]: https://github.com/alessio-ragni/k0-board/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/alessio-ragni/k0-board/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/alessio-ragni/k0-board/releases/tag/v0.1.0

package/README.md

@@ -133,7 +133,7 @@ Nothing on this list happens before you have seen it and said yes. Everything on
 | What | Where | Why |
 |---|---|---|
 | A copy of k0 | `~/.k0/app` | so the service does not point at a temporary npx cache |
-| Your board, logs and cache | `~/.k0/` | `%LOCALAPPDATA%\k0` on Windows |
+| Your board, settings, logs and cache | `~/.k0/` | `%LOCALAPPDATA%\k0` on Windows |
 | A service that starts at login | LaunchAgents · systemd user unit · Task Scheduler | so k0 is simply there |
 | **macOS only** — one administrator rule | `/etc/sudoers.d/k0-pmset` | to keep the Mac awake with the lid closed. Asks for your password once, and grants exactly two command lines |
 | **macOS only** — one key binding | your Terminal profile (backed up first) | so Shift+Enter starts a new line |
@@ -200,8 +200,10 @@ k0 makes **no network requests**. Not one, not even for a font.
 - **double click** — brings that session's terminal back to the front, even if you had minimised
   it. It is what stops you losing track of which window is which.
 
-- **Resume** — appears once you have closed the terminal: it reopens the same conversation exactly
-  where it was.
+- **Resume** — appears once the terminal has been closed, by you or by k0 after a long silence: it
+  reopens the same conversation exactly where it was. The card's prompt is **not** put back in —
+  that conversation answered it hours ago, and typing it in again would be at best something stale
+  in the way.
 
 - **Done** — closes the work **and its terminal**, with no questions: undo it with **Reopen**, and
   pick the conversation up again with **Resume**. It is not on backlog cards: they never started.
@@ -512,6 +514,47 @@ Reading the process table costs little on a calm machine and a lot on a struggli
 exactly when you look at it. So it is sampled every three seconds, and **only while the board is
 open**.
 
+### And the ones you forget, k0 closes for you
+
+The paragraph above assumes you noticed. Most of the time nobody does: the window that is costing
+you a gigabyte is the one you stopped thinking about yesterday. So **after twelve hours with
+nothing happening, k0 does that `Close` itself** — the session is stopped, its window goes, and the
+memory comes back.
+
+Nothing is lost by it. The card stays exactly where it is with the status it had, and **Resume**
+picks the conversation up where it was. That is the whole reason this is safe: a closed terminal
+has never been a lost session.
+
+**Only yellow is ever touched** — *Your turn*, the ball in your court and nothing happening. The
+rest is left alone, and each for its own reason:
+
+- **Working** and **Planning** are somebody mid-thought. Stopping one is not memory saved, it is
+  work lost — the same rule the `Close` link has always followed.
+- **Needs answer** and **Needs approval** would lose the very thing they were showing you. A
+  question and a finished plan are drawn by the terminal and are not written to the transcript
+  until they are answered, so closing that window throws the question away.
+- A session sitting in a **shell** is left alone as well. That is a shell you dropped into, and
+  there may be a command of yours running in it; k0 cannot see what it is, so k0 does not touch it.
+  On the board it reads as yellow like any other, which is exactly why this one has to be said.
+
+And a window you were using an hour ago is never closed, whatever the card's history says. k0 has
+four clocks for a session — two of its own and two Claude Code keeps — and **the newest one wins**.
+Being wrong in that direction leaves a window open until tomorrow; being wrong the other way closes
+a terminal you were about to go back to.
+
+A card k0 tidied away says so: where one you closed yourself reads *session closed*, this one reads
+*closed automatically*. Same italic, same place, one word different.
+
+And the memory chip at the end of the top bar says it is watching, and from when: **RAM 79% · CPU
+19% · closes at 8h**, in lighter type than the numbers beside it. That is the whole announcement,
+and it is on that chip rather than anywhere else because that is where the memory is already being
+talked about — something that closes your windows for you should never be a surprise. Hover for
+the sentence. Switched off, the chip says nothing at all rather than *0h*, which would read as
+"closes immediately", and the hover is what tells you it is off.
+
+Twelve hours is what it does if you never say otherwise. `closeIdleTerminalsAfterHours` in the
+settings file changes it, and **`0` switches it off** — see below.
+
 ---
 
 ## Filling the board with what you have already done
@@ -722,6 +765,38 @@ Two side effects of the Cmd+V k0 uses to write your prompt, worth knowing:
 
 ---
 
+## Settings
+
+There is no settings page on the board, and there is not going to be one. The board is for what
+changes during a working day; a number you set once and then never look at again is the opposite of
+that, and putting it on screen would cost the one page that has to stay readable in exchange for
+nothing.
+
+So the settings are a file, and **the file is the list**:
+
+```
+~/.k0/config.json                        macOS and Linux
+%LOCALAPPDATA%\k0\config.json            Windows
+```
+
+k0 writes it on the first run with **every setting already in it at its default**, so opening it is
+how you find out what there is to change. It sits beside the board rather than inside the app —
+`npx` unpacks into a cache npm is free to wipe, and `k0-board install` overwrites the app
+directory, so a setting kept in there would not survive an update. Change it and k0 picks it up by
+itself on the next round: nothing to restart.
+
+| | |
+|---|---|
+| `closeIdleTerminalsAfterHours` | How long a yellow card's terminal may sit there before k0 closes it and gives the memory back. `12` if you say nothing. **`0` switches it off.** Anything under an hour is treated as an hour — below that this stops being a tidy-up and starts closing windows while you are using them. |
+
+Delete a line to go back to its default; a file k0 cannot read is ignored altogether and the
+defaults hold, rather than k0 refusing to start over a stray comma.
+
+**`k0-board doctor` prints the same list**, with the value actually in force and where the file is,
+for the times you would rather ask than go and look.
+
+---
+
 ## How it is put together
 
 No dependencies, nothing to compile. Change a file, reload the page.
@@ -744,7 +819,11 @@ server/
   guard.js       who is allowed to talk to this server at all: the Host and the Origin
   db.js          SQLite (node:sqlite): the card, session_event, pref and dev_server tables —
                  docs/database.md
-  paths.js       where the board, the logs and the cache live
+  paths.js       where the board, the logs, the settings and the cache live
+  settings.js    the few things you can change, and the file that is the list of them —
+                 ~/.k0/config.json, written out with everything in it and re-read when it changes
+  idle.js        which terminals have sat still long enough to be closed and given back. Only the
+                 deciding: it kills nothing, so every rule in it can be proved without a machine
   watcher.js     reads Claude Code's own files and derives the statuses; also renames a session
   git.js         the only one that talks to git: what is committed, what is pushed, whose it is,
                  and — for the ChangeLog — what the commits actually said

package/bin/k0-board.js

@@ -48,6 +48,7 @@ if (Number(process.versions.node.split('.')[0]) < MIN_NODE) {
 
 const { name: platformName, capabilities, notes, service, extras, shell } = await import('../platform/index.js')
 const paths = await import('../server/paths.js')
+const settings = await import('../server/settings.js')
 
 const APP_DIR = flag('from-source') ? SOURCE : paths.APP_DIR
 const ENTRY = path.join(APP_DIR, 'server', 'index.js')
@@ -420,6 +421,19 @@ async function doctor() {
   ]
   for (const [what, yes] of rows) (yes ? ok : warn)(what)
 
+  // The settings, in full, with what is actually in force. k0 has no settings page and is not
+  // getting one, so this — and the file itself — is where the list lives. Printing every key
+  // rather than only the ones somebody has changed is the point: it is an inventory.
+  step('Settings')
+  const conf = settings.status()
+  say(dim(`  ${conf.path}${conf.exists ? '' : ' (not written yet — the defaults are in force)'}`))
+  if (conf.broken) warn('this file could not be read: it is being ignored and the defaults are in force')
+  for (const [key, value] of Object.entries(conf.values)) {
+    const dflt = settings.DEFAULTS[key]
+    const off = key === 'closeIdleTerminalsAfterHours' && value === 0
+    say(`  ${bold(key)}  ${off ? 'off' : value}${value === dflt ? dim(' (default)') : dim(` (default ${dflt})`)}`)
+  }
+
   const explained = Object.entries(notes)
   if (explained.length) {
     step('Why not')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k0-board",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A board of sticky notes that drives your Claude Code sessions",
   "keywords": [
     "claude-code",

package/server/db.js

@@ -73,6 +73,7 @@ for (const [col, decl] of [
   ['imported_at', 'INTEGER'],
   ['work_path', 'TEXT'],
   ['head_at_start', 'TEXT'],
+  ['auto_closed', 'INTEGER NOT NULL DEFAULT 0'],
 ]) {
   const has = db.prepare('SELECT 1 FROM pragma_table_info(?) WHERE name = ?').get('card', col)
   if (!has) db.exec(`ALTER TABLE card ADD COLUMN ${col} ${decl}`)
@@ -214,6 +215,16 @@ export function setWorkPath(id, workPath) {
   return getCard(id)
 }
 
+/**
+ * Who shut this session's terminal: you, or k0 tidying up after a long silence. The card says so
+ * in one word, and the word has to be right — a window you closed yourself two minutes ago must
+ * not claim k0 did it. Does not touch `updated_at`: this is not work on the card.
+ */
+export function setAutoClosed(id, on) {
+  db.prepare('UPDATE card SET auto_closed = ? WHERE id = ?').run(on ? 1 : 0, id)
+  return getCard(id)
+}
+
 /** Where HEAD was when the session started: everything after it is this session's doing. */
 export function setHeadAtStart(id, sha) {
   db.prepare('UPDATE card SET head_at_start = ? WHERE id = ?').run(sha || null, id)

package/server/idle.js

@@ -0,0 +1,56 @@
+/**
+ * Which terminals have been sitting there long enough to be worth giving back.
+ *
+ * A session left open costs memory whether or not anybody is looking at it: the `claude` process,
+ * the MCP servers it started, the browsers those opened. `Close` on a card has always been the
+ * cure — it stops the session and shuts its window, leaves the card exactly where it is, and
+ * `Resume` picks the conversation up where it was. This is that same gesture, remembered for you.
+ *
+ * Only the deciding lives here. Nothing in this file kills anything, opens anything or reads a
+ * disk, which is what lets every rule below be proved without a machine to prove it on.
+ */
+
+const HOUR = 3600000
+
+/**
+ * The cards whose terminal should go, most of the rules being about what to leave alone.
+ *
+ * Yellow only — `IDLE`, the ball in your court. Not because the others are less forgotten but
+ * because of what closing them would destroy: a question and a finished plan are drawn by the
+ * terminal and are not in the transcript yet, so shutting that window throws away the very thing
+ * it was showing you. `WORKING` and `PLANNING` are somebody mid-thought. And a session Claude
+ * Code reports as `shell` is a shell you dropped into, which may well have a command of yours
+ * running in it — k0 does not know what, so k0 does not touch it.
+ */
+export function dueForClose({ cards, live, hours, now = Date.now() }) {
+  if (!(hours > 0)) return [] // switched off, and nothing to think about
+  const deadline = now - hours * HOUR
+  return cards.filter((card) => {
+    if (card.completed_at || !card.session_id || !card.session_alive) return false
+    if (card.status !== 'IDLE') return false
+    const session = live.get(card.session_id)
+    if (!session || session.status !== 'idle') return false
+    return lastSignOfLife(card, session) <= deadline
+  })
+}
+
+/**
+ * The most recent sign that something happened here, from every source that keeps one, and the
+ * newest of them wins.
+ *
+ * Taking the maximum is the whole safety of this feature. Being wrong in that direction leaves a
+ * window open and costs a few hundred megabytes until tomorrow; being wrong the other way closes
+ * a terminal somebody was about to go back to. So a single stale clock can never be the one that
+ * decides.
+ *
+ * `updatedAt` and `statusUpdatedAt` come out of Claude Code's own `~/.claude/sessions/<pid>.json`,
+ * which k0 already reads every second and until now threw away. They move when the session really
+ * changes state and are not a heartbeat — a session that had been busy for twenty-three minutes
+ * was carrying timestamps twenty-three minutes old — so they say what they appear to say.
+ *
+ * `updated_at` matters for the case none of the others cover: resuming a card leaves the status at
+ * `IDLE`, so no new event is written and `status_since` stays as old as it was.
+ */
+export function lastSignOfLife(card, session) {
+  return Math.max(card.updated_at || 0, card.status_since || 0, session.updatedAt || 0, session.statusUpdatedAt || 0)
+}

package/server/index.js

@@ -16,6 +16,8 @@ import {
   relayoutWindows,
 } from './launcher.js'
 import * as mode from './mode.js'
+import * as settings from './settings.js'
+import { dueForClose } from './idle.js'
 import { listProjects, onDisk, projectName } from './projects.js'
 import { scanSessions } from './sessions.js'
 import * as git from './git.js'
@@ -65,7 +67,50 @@ function tick() {
   // The power levers are checked once a minute rather than every round: reading the power
   // state costs processes, and the things it has to follow — the mains plugged in or out, the
   // battery going down — do not change from one second to the next.
-  if (rounds++ % 60 === 0) mode.guard()
+  if (rounds % 60 === 0) mode.guard()
+  // The forgotten terminals, on the same cadence but half a minute off it, so the two jobs that
+  // only run once a minute never land in the same second as each other.
+  if (rounds % 60 === 30) sweepIdle(live)
+  rounds++
+}
+
+/**
+ * Gives back the memory of the windows you have stopped using.
+ *
+ * It does exactly what the `Close` link on a card does, and on purpose the same three moves and
+ * not a path of its own: stop the session, shut the window, forget the window. The card stays
+ * where it is with the status it had, `session_id` is untouched, and `Resume` picks the
+ * conversation up where it was — a closed terminal is not a lost session.
+ *
+ * Deliberately not awaited by `tick`: closing a terminal waits up to two seconds for the process
+ * to go, and the watching loop must not be held up by it. Hence the latch, the same one
+ * `machine.js` and `servers.js` keep for their own sampling — `setInterval` will happily start a
+ * second round on top of the first.
+ */
+let sweeping = false
+async function sweepIdle(live) {
+  if (sweeping) return
+  const hours = settings.read().closeIdleTerminalsAfterHours
+  const due = dueForClose({ cards: db.listCards(), live, hours })
+  if (!due.length) return
+  sweeping = true
+  try {
+    for (const card of due) {
+      try {
+        await closeTerminal({ winId: card.terminal_window_id, pid: live.get(card.session_id)?.pid })
+        db.setTerminalWindow(card.id, null) // that window is gone; Resume opens a new one
+        db.setAutoClosed(card.id, true)
+        console.log(`k0 — "${card.title}" sat still for ${hours}h: its terminal is closed, Resume picks it up`)
+      } catch (err) {
+        // One window that refuses to go must not take the others with it, and must certainly not
+        // take the server: nothing is awaiting this, so a rejection escaping here would end the
+        // process outright. It runs unattended — the next round is the retry.
+        console.error(`k0 — could not close the terminal of "${card.title}": ${String(err?.message || err)}`)
+      }
+    }
+  } finally {
+    sweeping = false
+  }
 }
 
 /** When somebody last looked at the board. */
@@ -186,6 +231,10 @@ function board() {
     mode: mode.current(),
     lid: mode.lid(),
     reason: mode.reason(),
+    // After how long a forgotten terminal is closed, so the machine chip can say that it is
+    // watching and after how long. Zero means it is switched off, and then the chip says nothing
+    // rather than saying "0h" — a number that would read as "closes immediately".
+    closeIdleAfterHours: settings.read().closeIdleTerminalsAfterHours,
     // What this machine can and cannot do, so the board greys out the rest and says why
     // instead of offering a button that quietly does nothing.
     platform: platformReport(),
@@ -623,6 +672,7 @@ async function api(req, res, url) {
       const pid = readLiveSessions().get(card.session_id)?.pid
       const out = await closeTerminal({ winId: card.terminal_window_id, pid })
       db.setTerminalWindow(id, null) // that window is gone; Resume opens a new one
+      db.setAutoClosed(id, false) // this one was you: the card must not say otherwise
       tick() // so the answer already carries the closed card, without waiting for the loop
       return send(res, 200, { ...out, card: db.getCard(id) })
     }
@@ -642,6 +692,7 @@ async function api(req, res, url) {
       try {
         const out = await launch({ card: db.getCard(id), sessionId, mode: resuming ? 'resume' : 'start' })
         db.setTerminalWindow(id, out.winId)
+        db.setAutoClosed(id, false) // there is a window again: whoever shut the last one is history
         tick()
         return send(res, 200, { ...out, card: db.getCard(id) })
       } catch (err) {
@@ -694,6 +745,9 @@ http
     }
   })
   .listen(PORT, '127.0.0.1', () => {
+    // The settings file, written out with everything in it the first time k0 runs: it is the only
+    // list of what can be changed, so it has to exist before anybody goes looking for it.
+    settings.ensure()
     tick()
     // The mode is remembered, and at startup it puts the machine back as it was: the sleep
     // levers and, where needed, the font size of terminals left open. The server restarts often

package/server/launcher.js

@@ -105,7 +105,11 @@ export async function launch({ card, sessionId, mode = 'start' }) {
   const up = await waitForSession(sessionId)
 
   if (autoSend) return { name, up, winId, pasted: true, autoSent: true }
-  if (!up || !card.prompt?.trim()) return { name, up, winId, pasted: false }
+  // The prompt belongs to the beginning. Resuming picks up a conversation that answered it hours
+  // ago, and putting it back under the cursor is at best a stale instruction in the way — at
+  // worst it is sent, because where pasting is unavailable the fallback below types it. This
+  // matters more now that k0 closes forgotten terminals by itself: a Resume is no longer rare.
+  if (resume || !up || !card.prompt?.trim()) return { name, up, winId, pasted: false }
 
   await waitForPrompt(winId)
 

package/server/paths.js

@@ -12,10 +12,11 @@ import { fileURLToPath } from 'node:url'
  * there is on borrowed time. Data now lives in a directory owned by the user, and the
  * installed copy of the app is disposable.
  *
- *   ~/.k0/k0.db      the board
- *   ~/.k0/app/       the installed copy of k0 (written by `k0-board install`)
- *   ~/.k0/logs/      service stdout/stderr
- *   ~/.k0/cache/     pasted images, the Chrome profile used for PDF export
+ *   ~/.k0/k0.db        the board
+ *   ~/.k0/config.json  the settings, written out with everything in it on the first run
+ *   ~/.k0/app/         the installed copy of k0 (written by `k0-board install`)
+ *   ~/.k0/logs/        service stdout/stderr
+ *   ~/.k0/cache/       pasted images, the Chrome profile used for PDF export
  *
  * On Windows the same tree goes under %LOCALAPPDATA%\k0, which is the local-only,
  * not-roamed location Windows expects for this kind of state.

package/server/settings.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { HOME } from './paths.js'
+
+/**
+ * The few things about k0 you are allowed to change, and the file they live in.
+ *
+ * k0 has never had one of these, and this is deliberately not the first room of a settings
+ * panel. The board shows what changes during a working day; a number you set once and then never
+ * look at again is the opposite of that, and putting it on screen would cost the one page that
+ * has to stay readable in exchange for nothing.
+ *
+ * So it is a file, and the file IS the list: k0 writes it out with every setting already in it at
+ * its default, so that opening it is how you find out what there is to change. `k0-board doctor`
+ * prints the same thing, for anyone who would rather ask than look.
+ *
+ * It lives beside the database and not inside the app, because the app directory is disposable —
+ * `npx` unpacks into a cache npm may wipe, and `k0-board install` overwrites it — and a setting
+ * an update throws away is not a setting. And it is read again whenever it changes, so editing
+ * it takes effect on the next round rather than after a restart.
+ */
+
+/** `K0_CONFIG` is how the tests stay away from the real file, the way `K0_DB` does for the board. */
+export const PATH = process.env.K0_CONFIG || path.join(HOME, 'config.json')
+
+/**
+ * Every setting there is, and what it is worth if you never touch the file. No default is written
+ * down anywhere else: this object is the whole answer to "and if I leave it alone?".
+ */
+export const DEFAULTS = {
+  closeIdleTerminalsAfterHours: 12,
+}
+
+/**
+ * The shortest timeout that is still a timeout. The sweep goes round once a minute, and a
+ * terminal you were typing into ten minutes ago is not one you have forgotten: below an hour this
+ * stops being a tidy-up and becomes a machine closing windows while you are using them. A number
+ * under it is raised rather than refused — the intent was clearly "be aggressive about it", and an
+ * hour is as aggressive as this is willing to be.
+ */
+export const MIN_HOURS = 1
+
+/** The line k0 leaves at the top of the file, since JSON has nowhere else to put a word. */
+const NOTE =
+  'k0 wrote this file and reads it again by itself whenever it changes — nothing to restart. ' +
+  'Delete a line to go back to its default. Hours at 0 switch that closing off entirely. ' +
+  'See Settings in the README.'
+
+/**
+ * How long a terminal may sit there. Anything that is not a number falls back to the default
+ * rather than blowing up: this arrives from a file somebody edits by hand, and from there
+ * anything can arrive. Zero and below mean off, which is how the whole thing is switched off
+ * without a second switch to be kept in step with the first.
+ */
+export function idleHours(raw) {
+  if (raw === undefined || raw === null || raw === '') return DEFAULTS.closeIdleTerminalsAfterHours
+  const n = Number(raw)
+  if (!Number.isFinite(n)) return DEFAULTS.closeIdleTerminalsAfterHours
+  if (n <= 0) return 0
+  return Math.max(MIN_HOURS, n)
+}
+
+/** A file's worth of anything, turned into settings that can be trusted. Pure: the tests live here. */
+export function normalise(raw) {
+  const o = raw && typeof raw === 'object' ? raw : {}
+  return { closeIdleTerminalsAfterHours: idleHours(o.closeIdleTerminalsAfterHours) }
+}
+
+let cached = null
+let stamp = null // the mtime the cache was built from, or null for "there was no file"
+let broken = false
+
+/**
+ * The settings in force. The file is only re-read when its mtime moves, so this can be called
+ * from the watching loop without costing a read a second, and changing the file still lands
+ * without a restart.
+ */
+export function read() {
+  let mtime = null
+  try {
+    mtime = fs.statSync(PATH).mtimeMs
+  } catch {
+    /* no file: the defaults hold, and there is nothing to remember */
+  }
+  if (cached && stamp === mtime) return cached
+  stamp = mtime
+  if (mtime === null) broken = false // a file that is not there is not a file that is broken
+  cached = normalise(mtime === null ? null : parse())
+  return cached
+}
+
+function parse() {
+  try {
+    broken = false
+    return JSON.parse(fs.readFileSync(PATH, 'utf8'))
+  } catch {
+    // Half-saved by an editor, or one comma too many. k0 goes on with the defaults rather than
+    // refusing to start, and `doctor` is where you find out the file is being ignored — silence
+    // would be the worst of both: a setting you believe is in force and is not.
+    broken = true
+    return null
+  }
+}
+
+/**
+ * Writes the file out, with everything in it, if it is not there yet. Called explicitly at
+ * startup rather than from an import: a module that writes to your disk merely because somebody
+ * mentioned it is a module nobody can reason about.
+ */
+export function ensure() {
+  if (fs.existsSync(PATH)) return false
+  fs.mkdirSync(path.dirname(PATH), { recursive: true })
+  fs.writeFileSync(PATH, JSON.stringify({ '//': NOTE, ...DEFAULTS }, null, 2) + '\n')
+  return true
+}
+
+/** What the doctor prints: where the file is, whether it could be read, and what is in force. */
+export function status() {
+  const values = read()
+  return { path: PATH, exists: stamp !== null, broken, values }
+}

package/web/board.css

@@ -88,6 +88,10 @@ body {
   flex: none;
   background: var(--calm);
 }
+/* That k0 is looking after the memory for you is worth knowing once and then forgetting: it sits
+   on the same chip, lighter than the numbers beside it, because the numbers are what you came to
+   read and this is only there so the closing is never a surprise. */
+.gauge .idle { font-weight: 500; opacity: .6; margin-left: -2px; white-space: nowrap; }
 .gauge.warn i { background: var(--warn); }
 .gauge.bad i { background: var(--alert); }
 /* Solid red only when it is critical: the one moment it is allowed to interrupt. */

package/web/board.js

@@ -111,7 +111,13 @@ function postit(card, now) {
         : ''
     }
     <div class="foot">
-      ${dead ? '<span class="dead">session closed</span>' : ''}
+      ${
+        // Whoever shut the window, said in the same breath and the same weight — this line is
+        // already only an italic, and it stays one. Which of the two it is does not need its own
+        // place in the redraw signature: `auto_closed` never moves without `session_alive`
+        // moving with it, and that one is in there.
+        dead ? `<span class="dead">${card.auto_closed ? 'closed automatically' : 'session closed'}</span>` : ''
+      }
       <span class="since" title="${LABEL[card.status]} for ${since(card.status_since, now)}">${since(card.status_since, now)}</span>
     </div>
     <div class="actions"></div>`
@@ -559,7 +565,7 @@ function repoColumn(projects, shown) {
  * is nearly always. The colour is the kernel's judgement, not a threshold invented here: green
  * while it says all is well, amber at the first warning, red when it is critical.
  */
-function renderMachine(m, cards) {
+function renderMachine(m, cards, idleHours = 0) {
   const el = $('#gauge')
   if (!m?.mem) return el.setAttribute('hidden', '') // the first sample is not in yet
   el.removeAttribute('hidden')
@@ -567,7 +573,12 @@ function renderMachine(m, cards) {
 
   const ram = Math.round((m.mem.used / m.mem.total) * 100)
   const cpu = m.cpu === null ? '—' : `${Math.round(m.cpu * 100)}%`
-  el.innerHTML = `<i></i>RAM ${ram}% · CPU ${cpu}`
+  // Whether anybody is looking after the memory for you, and after how long. It belongs on this
+  // chip and nowhere else: this is where the memory is already being talked about, and a thing
+  // that quietly closes your windows should not be something you have to know about beforehand.
+  // Its presence is the whole message — switched off, there is nothing here rather than a nought.
+  const closes = idleHours > 0 ? `<span class="idle">· closes at ${idleHours}h</span>` : ''
+  el.innerHTML = `<i></i>RAM ${ram}% · CPU ${cpu}${closes}`
 
   const top = cards.find((c) => c.id === heaviest)
   const lines = [
@@ -577,6 +588,13 @@ function renderMachine(m, cards) {
   if (top?.load) lines.push(`heaviest: ${top.title} — ${weight(top.load.rss)}`)
   // What is heavy and is not k0: without it, the board would take blame that belongs to Chrome.
   if (m.others?.length) lines.push(`outside k0: ${m.others.map((o) => `${o.name} ${gb(o.rss)}`).join(' · ')}`)
+  // The chip has room for three words; the sentence that explains them goes here, and it is also
+  // the only place that can say the closing is switched off — the chip says that by staying quiet.
+  lines.push(
+    idleHours > 0
+      ? `a terminal nobody touches for ${idleHours}h is closed and its memory given back — the card stays, Resume picks it up`
+      : 'closing forgotten terminals is switched off'
+  )
   lines.push(showLoad ? 'click to hide the weight on each card' : 'click to show the weight on each card')
   el.title = lines.join('\n')
 }
@@ -857,7 +875,7 @@ async function refresh() {
     // What is eating most right now: it is what tints that one red and nobody else.
     heaviest =
       data.cards.filter((c) => c.load).sort((a, b) => b.load.rss - a.load.rss)[0]?.id ?? null
-    renderMachine(machine, data.cards)
+    renderMachine(machine, data.cards, data.closeIdleAfterHours)
 
     // Redraw only if something really changed, so the editor and the focus stay where they are.
     // The git state is inside the signature: without it, the mark would stay the one from the