meanwhile-cli 0.1.0__tar.gz → 0.1.2__tar.gz

{meanwhile_cli-0.1.0 → meanwhile_cli-0.1.2}/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "meanwhile",
       "source": ".",
-      "version": "0.1.0",
+      "version": "0.1.2",
       "description": "Play a quiz about your own repository while Claude Code is working, so your context stays loaded for the diff review that follows."
     }
   ]

{meanwhile_cli-0.1.0 → meanwhile_cli-0.1.2}/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "meanwhile",
   "description": "Play a quiz about your own repository while Claude Code is working, so your context stays loaded for the diff review that follows.",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "author": {
     "name": "Ismail Bayram"
   },

meanwhile_cli-0.1.2/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.5
+Name: meanwhile-cli
+Version: 0.1.2
+Summary: Play a quiz about your own repository while your coding agent works
+Project-URL: Homepage, https://github.com/ismailbayram/meanwhile
+Project-URL: Repository, https://github.com/ismailbayram/meanwhile
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: textual>=0.80
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# meanwhile
+
+A quiz about your own repository that you play while your coding agent works,
+so the code is still fresh in your head when the diff lands. Works with
+Claude Code, Codex, Cursor and OpenCode.
+
+<p align="center">
+  <img src="docs/images/card.svg" alt="A multiple-choice card about the repository, waiting for an answer" width="720">
+</p>
+
+<p align="center">
+  <img src="docs/images/done.svg" alt="The answered card, with a banner saying Claude Code is done" width="720">
+</p>
+
+## Quick start
+
+Three steps, once per machine and project:
+
+1. **Connect your agent** — see [Installation](#installation) for your agent.
+2. **Build the question pool**, once per project:
+   - Claude Code: run `/meanwhile-build`
+   - any other agent: run `uvx meanwhile-cli build-prompt --lang en --repo .`
+     and paste the output to your agent
+3. **Open a second terminal** in the same directory as your agent and run:
+
+   ```
+   uvx meanwhile-cli
+   ```
+
+The pane starts asking questions right away. When your agent finishes a
+prompt, the pane tells you so you can switch back to the diff.
+
+## Installation
+
+You need [uv](https://docs.astral.sh/uv/) for the `uvx` commands. Then pick
+your agent:
+
+### Claude Code
+
+```
+/plugin marketplace add ismailbayram/meanwhile
+/plugin install meanwhile@meanwhile
+```
+
+Restart Claude Code.
+
+### Codex
+
+```
+codex plugin marketplace add ismailbayram/meanwhile
+```
+
+Install `meanwhile` from the Plugins Directory, then **review and trust its
+hooks** — Codex skips plugin hooks until you do.
+
+### Cursor
+
+```
+uvx meanwhile-cli hooks install --agent cursor
+```
+
+### OpenCode
+
+```
+uvx meanwhile-cli hooks install --agent opencode
+```
+
+Restart OpenCode.
+
+### Installing the command permanently (optional)
+
+`uvx` runs the latest version without installing anything. If you prefer a
+regular command:
+
+```
+uv tool install meanwhile-cli    # or: pipx install meanwhile-cli
+```
+
+The command is then just `meanwhile` — use it wherever this README says
+`uvx meanwhile-cli`.
+
+## Usage
+
+| Key | Action |
+| --- | --- |
+| `1`–`9` | answer |
+| `space` | next card |
+| `q` | quit |
+
+- Start the pane **from the same directory you started your agent in**,
+  otherwise it cannot tell when the agent is done. The quiz itself works
+  either way.
+- Leave it open all day. Each new prompt after the agent finishes deals a
+  fresh round; when the pool runs out, `space` starts a new one.
+- The interface follows the pool's language. Override it with
+  `--lang tr` or `--lang en`.
+
+## The question pool
+
+`/meanwhile-build` (or `build-prompt`) has the agent read your repository and
+write `.meanwhile/pool.json` — 30 to 50 multiple-choice questions. An entry
+looks like this:
+
+```json
+{
+  "type": "quiz",
+  "q": "What happens to an order's reserved stock when payment fails?",
+  "choices": [
+    "It stays reserved until an admin releases it",
+    "It is released back to inventory after 15 minutes",
+    "It is released immediately and the order is cancelled"
+  ],
+  "answer": 1,
+  "why": "release_expired_reservations runs every 15 minutes and returns unpaid stock to inventory.",
+  "source": "shop/orders/tasks.py"
+}
+```
+
+- **Commit `pool.json`** so the whole team plays the same pool and nobody pays
+  to build it again.
+- **Language:** `--lang` takes a language code, not a name. `tr` and `en` are
+  the two the interface speaks; any other code (`de`, `fr`, …) writes the
+  questions in that language and keeps the interface in English.
+- **Adding questions:** run the build step again. When a pool already
+  exists it keeps every question and adds 30 new ones. Ask your agent for
+  "a fresh pool" if you want to replace it instead.
+- **Refreshing:** when the repository is about 50 commits past the pool, the
+  pane shows a banner. Run the build step again and commit the new file.
+  Nothing is regenerated automatically.
+- **Repeats:** within a round no question repeats. Across rounds, questions
+  you have not answered yet come first; once you have answered them all, it
+  starts over.
+- Scores and the answered-question list are kept in
+  `.meanwhile/scores.json`, which is gitignored.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `uvx meanwhile-cli` | open the quiz pane |
+| `uvx meanwhile-cli build-prompt --lang en --repo .` | print the pool-building instructions for any agent |
+| `uvx meanwhile-cli validate --repo .` | check `pool.json` |
+| `uvx meanwhile-cli hooks install --agent <agent>` | connect an agent without its plugin (`claude`, `codex`, `cursor`, `opencode`); add `--user` for every project (not Cursor) |
+| `uvx meanwhile-cli hooks status` | show which agents are connected |
+| `uvx meanwhile-cli hooks uninstall --agent <agent>` | disconnect |
+
+`hooks install` writes an absolute path from your machine into the agent's
+config, so don't commit that file for Codex, Cursor or OpenCode.
+
+## How it works
+
+Hooks in your agent write `busy` or `idle` to a small file in
+`~/.meanwhile/state/` when you send a prompt and when the agent finishes. The
+pane watches that file and shows cards from `pool.json`. Only the build step
+uses an LLM; the pane makes no network calls.
+
+## Development
+
+From a checkout of this repository, use `uv run meanwhile` in place of
+`uvx meanwhile-cli`, and `/plugin marketplace add /path/to/meanwhile` for the
+Claude Code plugin. Tests: `uv run --extra dev python -m pytest`.

meanwhile_cli-0.1.2/README.md

@@ -0,0 +1,161 @@
+# meanwhile
+
+A quiz about your own repository that you play while your coding agent works,
+so the code is still fresh in your head when the diff lands. Works with
+Claude Code, Codex, Cursor and OpenCode.
+
+<p align="center">
+  <img src="docs/images/card.svg" alt="A multiple-choice card about the repository, waiting for an answer" width="720">
+</p>
+
+<p align="center">
+  <img src="docs/images/done.svg" alt="The answered card, with a banner saying Claude Code is done" width="720">
+</p>
+
+## Quick start
+
+Three steps, once per machine and project:
+
+1. **Connect your agent** — see [Installation](#installation) for your agent.
+2. **Build the question pool**, once per project:
+   - Claude Code: run `/meanwhile-build`
+   - any other agent: run `uvx meanwhile-cli build-prompt --lang en --repo .`
+     and paste the output to your agent
+3. **Open a second terminal** in the same directory as your agent and run:
+
+   ```
+   uvx meanwhile-cli
+   ```
+
+The pane starts asking questions right away. When your agent finishes a
+prompt, the pane tells you so you can switch back to the diff.
+
+## Installation
+
+You need [uv](https://docs.astral.sh/uv/) for the `uvx` commands. Then pick
+your agent:
+
+### Claude Code
+
+```
+/plugin marketplace add ismailbayram/meanwhile
+/plugin install meanwhile@meanwhile
+```
+
+Restart Claude Code.
+
+### Codex
+
+```
+codex plugin marketplace add ismailbayram/meanwhile
+```
+
+Install `meanwhile` from the Plugins Directory, then **review and trust its
+hooks** — Codex skips plugin hooks until you do.
+
+### Cursor
+
+```
+uvx meanwhile-cli hooks install --agent cursor
+```
+
+### OpenCode
+
+```
+uvx meanwhile-cli hooks install --agent opencode
+```
+
+Restart OpenCode.
+
+### Installing the command permanently (optional)
+
+`uvx` runs the latest version without installing anything. If you prefer a
+regular command:
+
+```
+uv tool install meanwhile-cli    # or: pipx install meanwhile-cli
+```
+
+The command is then just `meanwhile` — use it wherever this README says
+`uvx meanwhile-cli`.
+
+## Usage
+
+| Key | Action |
+| --- | --- |
+| `1`–`9` | answer |
+| `space` | next card |
+| `q` | quit |
+
+- Start the pane **from the same directory you started your agent in**,
+  otherwise it cannot tell when the agent is done. The quiz itself works
+  either way.
+- Leave it open all day. Each new prompt after the agent finishes deals a
+  fresh round; when the pool runs out, `space` starts a new one.
+- The interface follows the pool's language. Override it with
+  `--lang tr` or `--lang en`.
+
+## The question pool
+
+`/meanwhile-build` (or `build-prompt`) has the agent read your repository and
+write `.meanwhile/pool.json` — 30 to 50 multiple-choice questions. An entry
+looks like this:
+
+```json
+{
+  "type": "quiz",
+  "q": "What happens to an order's reserved stock when payment fails?",
+  "choices": [
+    "It stays reserved until an admin releases it",
+    "It is released back to inventory after 15 minutes",
+    "It is released immediately and the order is cancelled"
+  ],
+  "answer": 1,
+  "why": "release_expired_reservations runs every 15 minutes and returns unpaid stock to inventory.",
+  "source": "shop/orders/tasks.py"
+}
+```
+
+- **Commit `pool.json`** so the whole team plays the same pool and nobody pays
+  to build it again.
+- **Language:** `--lang` takes a language code, not a name. `tr` and `en` are
+  the two the interface speaks; any other code (`de`, `fr`, …) writes the
+  questions in that language and keeps the interface in English.
+- **Adding questions:** run the build step again. When a pool already
+  exists it keeps every question and adds 30 new ones. Ask your agent for
+  "a fresh pool" if you want to replace it instead.
+- **Refreshing:** when the repository is about 50 commits past the pool, the
+  pane shows a banner. Run the build step again and commit the new file.
+  Nothing is regenerated automatically.
+- **Repeats:** within a round no question repeats. Across rounds, questions
+  you have not answered yet come first; once you have answered them all, it
+  starts over.
+- Scores and the answered-question list are kept in
+  `.meanwhile/scores.json`, which is gitignored.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `uvx meanwhile-cli` | open the quiz pane |
+| `uvx meanwhile-cli build-prompt --lang en --repo .` | print the pool-building instructions for any agent |
+| `uvx meanwhile-cli validate --repo .` | check `pool.json` |
+| `uvx meanwhile-cli hooks install --agent <agent>` | connect an agent without its plugin (`claude`, `codex`, `cursor`, `opencode`); add `--user` for every project (not Cursor) |
+| `uvx meanwhile-cli hooks status` | show which agents are connected |
+| `uvx meanwhile-cli hooks uninstall --agent <agent>` | disconnect |
+
+`hooks install` writes an absolute path from your machine into the agent's
+config, so don't commit that file for Codex, Cursor or OpenCode.
+
+## How it works
+
+Hooks in your agent write `busy` or `idle` to a small file in
+`~/.meanwhile/state/` when you send a prompt and when the agent finishes. The
+pane watches that file and shows cards from `pool.json`. Only the build step
+uses an LLM; the pane makes no network calls.
+
+## Development
+
+From a checkout of this repository, use `uv run meanwhile` in place of
+`uvx meanwhile-cli`, and `/plugin marketplace add /path/to/meanwhile` for the
+Claude Code plugin. Tests: `uv run --extra dev python -m pytest`.

{meanwhile_cli-0.1.0 → meanwhile_cli-0.1.2}/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "meanwhile",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Play a quiz about your own repository while Claude Code is working, so your context stays loaded for the diff review that follows.",
   "author": {
     "name": "Ismail Bayram"

{meanwhile_cli-0.1.0 → meanwhile_cli-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meanwhile-cli"
-version = "0.1.0"
+version = "0.1.2"
 description = "Play a quiz about your own repository while your coding agent works"
 readme = "README.md"
 requires-python = ">=3.10"

meanwhile_cli-0.1.2/src/meanwhile/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

{meanwhile_cli-0.1.0 → meanwhile_cli-0.1.2}/src/meanwhile/app.py

@@ -12,9 +12,9 @@ from textual.widgets import Footer, Static
 from . import agents, game, scores, strings
 from .pool import Pool, QuizItem
 
-# Lifecycle phases. The pane is opened once and left open: it waits for the
-# agent to start, plays for exactly as long as it is busy, then waits again.
-WAITING = "waiting"
+# Lifecycle phases. The pane deals cards as soon as it opens — a pool is all
+# it needs. The agent's hooks only add to that: an idle edge freezes the card
+# and says the agent is done, and the next busy edge deals a fresh round.
 PLAYING = "playing"
 DONE = "done"
 
@@ -52,11 +52,16 @@ class MeanwhileApp(App):
         self.poll_seconds = poll_seconds
         self.language = language
         self.agent_source = agent_source
-        self.session = game.start_session(pool)
-        self.phase = WAITING
+        self.session = self._deal()
+        self.phase = PLAYING
         self._last_status = "idle"
         self._answered = False
 
+    def _deal(self) -> game.Session:
+        """A fresh round, questions this player has not answered yet first."""
+        seen = scores.load_seen(self.repo_dir) if self.repo_dir is not None else set()
+        return game.start_session(self.pool, seen=seen)
+
     def _agent_name(self) -> str:
         return agents.label_for(self.agent_source()) or strings.text(self.language, "agent")
 
@@ -115,8 +120,12 @@ class MeanwhileApp(App):
             self._finish_playing()
 
     def _start_playing(self) -> None:
+        if self.phase == PLAYING:
+            # Already dealing — the pane was opened before the prompt. Keep the
+            # card on screen rather than reshuffling under the player.
+            return
         self.phase = PLAYING
-        self.session = game.start_session(self.pool)  # re-shuffled: the cards come back
+        self.session = self._deal()  # re-shuffled: the cards come back
         self._answered = False
         self.query_one("#status").update("")
         self.query_one("#feedback").update("")
@@ -128,14 +137,24 @@ class MeanwhileApp(App):
         self.phase = DONE
         self.refresh_bindings()  # DONE takes no input: the card keys leave the footer
         self.query_one("#status").update(strings.text(self.language, "done", agent=self._agent_name()))
-        # Exactly once per session: the `phase != PLAYING` guard above is what
-        # guarantees it — the only way back into PLAYING is _start_playing,
-        # which deals a new session.
+        self._record()
+
+    def _record(self) -> None:
+        # Exactly once per session: both callers leave PLAYING first, and the
+        # only way back into it is _start_playing, which deals a new session.
         if self.repo_dir is not None and self.session.answered:
             scores.record_session(self.repo_dir, self.session)
 
     # --- actions --------------------------------------------------------
 
+    async def action_quit(self) -> None:
+        # Without hooks there is never an idle edge, so quitting is the only
+        # moment a session ends. Score it here rather than lose it.
+        if self.phase == PLAYING:
+            self.phase = DONE
+            self._record()
+        self.exit()
+
     def action_choose(self, number: int) -> None:
         item = game.current(self.session)
         if self.phase != PLAYING or self._answered or not isinstance(item, QuizItem):
@@ -144,9 +163,24 @@ class MeanwhileApp(App):
         if not 0 <= index < len(item.choices):
             return
         self._resolve(game.answer(self.session, index))
+        if self.repo_dir is not None:
+            scores.mark_seen(
+                self.repo_dir, game.item_key(item), {game.item_key(i) for i in self.pool.items}
+            )
 
     def action_next(self) -> None:
-        if self.phase != PLAYING or not self._answered:
+        if self.phase != PLAYING:
+            return
+        if game.current(self.session) is None:
+            # Out of cards. Without hooks no busy edge will ever come to deal
+            # another round, so `space` does it: bank this one, start afresh.
+            self._record()
+            self.session = self._deal()
+            self._answered = False
+            self.query_one("#feedback").update("")
+            self._render()
+            return
+        if not self._answered:
             return
         game.advance(self.session)
         self._answered = False
@@ -166,12 +200,6 @@ class MeanwhileApp(App):
         # `check_action` has too.
         self.refresh_bindings()
         card = self.query_one("#card")
-        if self.phase == WAITING:
-            self.query_one("#status").update(strings.text(self.language, "waiting", agent=self._agent_name()))
-            card.update("")
-            self.query_one("#score").update("")
-            return
-
         item = game.current(self.session)
         if item is None:
             card.update(strings.text(self.language, "exhausted"))

{meanwhile_cli-0.1.0 → meanwhile_cli-0.1.2}/src/meanwhile/build_prompt.md

@@ -20,9 +20,26 @@ pool's `language` field records exactly that code. `tr` and `en` are the two
 the playing interface itself speaks; any other code is still fine — the cards
 get written in that language and the interface stays English.
 
+## Extending an existing pool
+
+If `.meanwhile/pool.json` already exists, extend it rather than replacing it,
+unless the user asked for a fresh pool:
+
+- Keep every existing item exactly as it is — players' progress is keyed on
+  the question text, so a reworded question counts as a new one. Only drop
+  an item whose `source` file no longer exists.
+- Add 30 new items. None may ask what an existing item already asks; read
+  the existing questions first, and look for parts of the repository they
+  do not cover yet.
+- Keep the pool's own `language` — it wins over the language named above,
+  which is only a default — unless the user asked for another one.
+- Set `builtAt` and `headSha` to today and the current commit.
+
 ## What to write
 
-Write `.meanwhile/pool.json` with 30-50 `quiz` items, using exactly this shape:
+For a new pool, write `.meanwhile/pool.json` with 30-50 `quiz` items; when
+extending, keep the same envelope and append to `items`. Use exactly this
+shape:
 
     {
       "builtAt": "<today, YYYY-MM-DD>",
@@ -60,7 +77,8 @@ Rules:
 2. Run `uvx meanwhile-cli validate --repo .` (during development, from a
    checkout of this plugin: `uv run meanwhile validate --repo .`) and fix
    anything it reports.
-3. Tell the user the item count and that `.meanwhile/pool.json` is ready to
+3. Tell the user the item count — when extending, how many were added and
+   how many there are now — and that `.meanwhile/pool.json` is ready to
    commit so their team shares the pool.
 4. Tell the user how to play, in {language} — building the pool starts
    nothing, and no other step says how. Give them the command itself, in a

{meanwhile_cli-0.1.0 → meanwhile_cli-0.1.2}/src/meanwhile/game.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import hashlib
 import random
 from dataclasses import dataclass, field
 
@@ -31,10 +32,26 @@ class Session:
     _answered_index: int = field(default=-1, init=False, repr=False, compare=False)
 
 
-def start_session(pool: Pool, rng: random.Random | None = None) -> Session:
-    items = list(pool.items)
-    (rng or random.Random()).shuffle(items)
-    return Session(items=items)
+def item_key(item) -> str:
+    """A stable name for a question, for remembering it was answered.
+
+    The question text, not the item's position: a rebuilt or extended pool
+    reorders items, and a question that survives a rebuild word for word is
+    the same question to the player.
+    """
+    return hashlib.sha256(item.q.encode("utf-8")).hexdigest()[:16]
+
+
+def start_session(
+    pool: Pool, rng: random.Random | None = None, seen: frozenset[str] | set[str] = frozenset()
+) -> Session:
+    """A shuffled round over the whole pool, questions not in `seen` first."""
+    rng = rng or random.Random()
+    fresh = [item for item in pool.items if item_key(item) not in seen]
+    repeats = [item for item in pool.items if item_key(item) in seen]
+    rng.shuffle(fresh)
+    rng.shuffle(repeats)
+    return Session(items=fresh + repeats)
 
 
 def finished(session: Session) -> bool:

meanwhile_cli-0.1.2/src/meanwhile/scores.py

@@ -0,0 +1,75 @@
+"""Per-developer running totals, and which questions this developer has
+answered. Gitignored: both are local, never shared."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from .game import Session
+
+SCORES_RELPATH = ".meanwhile/scores.json"
+_ZERO = {"answered": 0, "correct": 0, "best_streak": 0}
+
+
+def _path(repo_dir: str | Path) -> Path:
+    return Path(repo_dir) / SCORES_RELPATH
+
+
+def _read(repo_dir: str | Path) -> dict:
+    try:
+        data = json.loads(_path(repo_dir).read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _write(repo_dir: str | Path, totals: dict, seen: set[str]) -> None:
+    path = _path(repo_dir)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(f"{path.name}.tmp.{os.getpid()}")
+    tmp.write_text(json.dumps({**totals, "seen": sorted(seen)}, indent=2), encoding="utf-8")
+    tmp.replace(path)
+
+
+def load_scores(repo_dir: str | Path) -> dict:
+    data = _read(repo_dir)
+    out = dict(_ZERO)
+    for key in out:
+        value = data.get(key, 0)
+        out[key] = value if isinstance(value, int) and value >= 0 else 0
+    return out
+
+
+def record_session(repo_dir: str | Path, session: Session) -> dict:
+    totals = load_scores(repo_dir)
+    totals["answered"] += session.answered
+    totals["correct"] += session.correct
+    totals["best_streak"] = max(totals["best_streak"], session.best_streak)
+    _write(repo_dir, totals, load_seen(repo_dir))
+    return totals
+
+
+def load_seen(repo_dir: str | Path) -> set[str]:
+    """The keys (see `game.item_key`) of the questions answered so far."""
+    seen = _read(repo_dir).get("seen", [])
+    if not isinstance(seen, list):
+        return set()
+    return {key for key in seen if isinstance(key, str)}
+
+
+def mark_seen(repo_dir: str | Path, key: str, pool_keys: set[str]) -> set[str]:
+    """Remember one answered question, and return what is remembered now.
+
+    Written on every answer rather than at the end of a round: a pane closed
+    with its terminal never reaches the end of a round. Once every question in
+    the pool has been answered the list starts over, so the next rounds go
+    back to a plain shuffle instead of ordering by a list that covers it all.
+    Keys of questions no longer in the pool are dropped on the way.
+    """
+    seen = (load_seen(repo_dir) & pool_keys) | {key}
+    if pool_keys <= seen:
+        seen = set()
+    _write(repo_dir, load_scores(repo_dir), seen)
+    return seen

{meanwhile_cli-0.1.0 → meanwhile_cli-0.1.2}/src/meanwhile/strings.py

@@ -1,4 +1,4 @@
-"""The interface's six strings, in the languages meanwhile ships.
+"""The interface's strings, in the languages meanwhile ships.
 
 A dictionary, deliberately, and not an i18n framework: there is no catalog to
 extract, no compilation step and no locale negotiation. The cards themselves
@@ -10,23 +10,21 @@ from __future__ import annotations
 
 DEFAULT_LANGUAGE = "en"
 
-KEYS = ("waiting", "done", "exhausted", "stale", "correct", "wrong", "agent")
+KEYS = ("done", "exhausted", "stale", "correct", "wrong", "agent")
 
 _TABLE = {
     "en": {
         "agent": "the agent",
-        "waiting": "Waiting for {agent} to start working — submit a prompt and the game begins.",
         "done": "{agent} is done ^ — switch back to the diff; this pane keeps running.",
-        "exhausted": "Pool exhausted for this wait — the next one deals a fresh round.",
+        "exhausted": "That was every question in the pool — press space for a fresh round.",
         "stale": "pool is {behind} commits behind — run the build command for fresh questions",
         "correct": "correct",
         "wrong": "wrong",
     },
     "tr": {
         "agent": "ajan",
-        "waiting": "{agent} çalışmaya başlayınca oyun başlıyor — bir istem gönder.",
         "done": "{agent} bitirdi ^ — diff'e dön; bu pencere açık kalıyor.",
-        "exhausted": "Bu bekleme için havuz bitti — sonraki bekleme yeni bir tur dağıtıyor.",
+        "exhausted": "Havuzdaki bütün sorular bitti — yeni tur için boşluğa bas.",
         "stale": "havuz {behind} commit geride — tazelemek için build komutunu çalıştır",
         "correct": "doğru",
         "wrong": "yanlış",