godotmaker-cli 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,64 @@
+# godotmaker-cli
+
+## 0.2.0
+
+### Minor Changes
+
+- [#2](https://github.com/RandallLiuXin/GodotMakerApp/pull/2) [`f075453`](https://github.com/RandallLiuXin/GodotMakerApp/commit/f075453cb04bc57e30fef5056f80f7bb9f60fcef) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Add an agent runner abstraction with Claude Code and Codex runner implementations, per-launch and config-driven agent selection, neutral preflight probing, Windows npm-shim agent launching, Codex PTY handoff, project-local Codex runtime validation, Git work-tree validation, and unknown-cost usage rendering for agents that do not report USD cost.
+
+- [`ae4e72a`](https://github.com/RandallLiuXin/GodotMakerApp/commit/ae4e72a85a2c9ad7424f2018d140f98450c18271) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Drop all numeric scoring from the evaluate path. `Evaluation` now carries a binary `verdict` (`approve` / `reject`) plus categorized issue arrays (critical / major / minor / gameplay / orphan tests); the legacy `overall` / `scores` / `passThreshold` model is gone. CLI surfaces the verdict in the Header eval cell as `✓ approved` (green) or `✗ Nc+Mm` (yellow, where N/M are critical / major counts); `--pass-threshold` flag and `pipeline.passThreshold` config are removed. Pre-v0.3.x `evaluation.json` files no longer parse — re-run `/gm-evaluate` to upgrade.
+
+### Patch Changes
+
+- [`e441348`](https://github.com/RandallLiuXin/GodotMakerApp/commit/e4413487d92b093e50aba1b6d04373ce823cf282) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - The accept stage no longer prompts mid-run for the `Bash` permission its decision-recording and stage-commit steps need; without it the user had to confirm each command and a denial halted the gate as a false failure.
+
+- [`c10ebbb`](https://github.com/RandallLiuXin/GodotMakerApp/commit/c10ebbbbb79ef2b24e55334feec9ef897ea28f1c) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Each cli launch resets iteration / build budgets to 0 (was a lifetime project cap that leaked across sessions); new `/refresh` slash command lets the user reset mid-session in idle / paused / finished / failed states.
+
+- [`916c3b3`](https://github.com/RandallLiuXin/GodotMakerApp/commit/916c3b368c63aad21c1a03108bb1b27304dfacb7) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - `/start` on a failed pipeline now reliably retries the run; an earlier fix in this release cycle left the keystroke without effect.
+
+- [`0d07944`](https://github.com/RandallLiuXin/GodotMakerApp/commit/0d07944e27699605e387f0797a594b127a99c52a) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Interactive stages (scaffold, gdd, accept) now hold the cli pipeline panel for 2 seconds before launching the agent, so the stage change is visible instead of flashing past too fast to read.
+
+- [`f3e3c7d`](https://github.com/RandallLiuXin/GodotMakerApp/commit/f3e3c7dccee6d9536dd40bf596979de312527b4f) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Clarify package license terms for npm distribution and generated project ownership.
+
+- [`8db205f`](https://github.com/RandallLiuXin/GodotMakerApp/commit/8db205fd4de00bc4f32347641f60fdeff61d742c) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Cli no longer exits after a successful first framework publish (R-310 followup) — the TTY handoff publish needs to release the terminal was previously misclassified as a permanent exit.
+
+- [`70e7f3c`](https://github.com/RandallLiuXin/GodotMakerApp/commit/70e7f3cc59edca719c6dc40b530d9165dc721f7f) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Fix the header run timer so it includes the active pipeline state's elapsed time instead of only settled stages.
+
+- [`614fb50`](https://github.com/RandallLiuXin/GodotMakerApp/commit/614fb50a29d7b3348e6e7699072dc1b14d9e0fb7) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - `/usage` "Recent runs" rows now show subagent dispatch + compaction counts as a tail clause (e.g. `3 subagents · 1 compaction`) when either is non-zero. Hidden otherwise to keep rows uncluttered on projects that do not have the upstream GodotMaker hook subsystem installed.
+
+- [`7fb1a86`](https://github.com/RandallLiuXin/GodotMakerApp/commit/7fb1a86439aa2431d48a8ace588c6875501fb3f7) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Fix: `/usage` "Recent runs" no longer shows duplicate entries after pausing via Ctrl-C or `q`. The cli was writing the same run summary to `usage.json` twice on the pause-and-unmount path — once from the paused branch and once from the post-loop persist block — producing two `recentRuns[]` entries with identical `startedAt`. The overlay rendered both rows and Ink reported a React key collision in the terminal.
+
+- [`3f7eb8d`](https://github.com/RandallLiuXin/GodotMakerApp/commit/3f7eb8de1e7746bf70b9e8f48614c714de15287d) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - `/start` is now valid from `failed` as a retry path. Pipeline failure lives only in memory (it does not touch `pipeline_state.json`), so re-issuing `/start` simply re-enters the state machine at the unchanged `currentState` — transient causes (quota 429, stream error) typically recover on retry. The footer on the failure screen now surfaces the `/start` option alongside `q` / `/quit`, and the `finished` message is no longer conflated with `failed` ("already finished. Restart the cli with --fresh to start over." vs the retry-friendly failure footer).
+
+- [`015df5f`](https://github.com/RandallLiuXin/GodotMakerApp/commit/015df5fb52db857fc944645f41ea9912139f4182) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Codex interactive stages (scaffold, gdd, accept) no longer flicker the bottom status bar on Windows.
+
+- [`f6f6598`](https://github.com/RandallLiuXin/GodotMakerApp/commit/f6f659836e34fa953de6b1ac6e784f4fbedeac7d) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Treat non-quota Codex stream error events as diagnostic session output instead of stage failure results, so successful stages no longer fail after Codex recovers the stream connection.
+
+- [`fc527b2`](https://github.com/RandallLiuXin/GodotMakerApp/commit/fc527b2a383fbad2b9379492d604cbd26329f13d) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Interactive pipeline stages (`scaffold` / `gdd` / `accept`) now record token usage in `.godotmaker/usage.json`. Previously their `--output-format stream-json` path was disabled (the spawn inherits stdio, so the cli could not read claude's output) and the states ended every run with 0 tokens despite real work. The runner now scans Claude Code's per-session record at `~/.claude/projects/<encoded-cwd>/*.jsonl` after the interactive process exits and forwards the recovered per-model totals to the same usage handler the non-interactive states use. Cost stays undefined for these stages (the session jsonl does not record `total_cost_usd`); the tracker treats missing cost as zero, so $ math stays correct but under-counts interactive-state spend.
+
+- [`d4ae310`](https://github.com/RandallLiuXin/GodotMakerApp/commit/d4ae310f17dadbb6dc5f1e38286c12eae53912f4) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - `runInteractive` now spawns the child claude session through a node-pty pseudo-terminal so keyboard input flows cleanly into claude on Windows. Adds `node-pty` as a runtime dependency.
+
+- [`16b5ee9`](https://github.com/RandallLiuXin/GodotMakerApp/commit/16b5ee9e7c7bcdedebb8964be3a1de3d69b7a3ca) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - `/usage` "Recent runs" now shows a per-state breakdown line (e.g. `scaffold 6m10s · gdd 58s`) under any row whose run visited more than one state, and `.godotmaker/usage.json` `recentRuns[]` persists the same data alongside the run-level totals. Older usage.json files without the field load as an empty map.
+
+- [`f65409f`](https://github.com/RandallLiuXin/GodotMakerApp/commit/f65409fe49025244909c2130811b4ab948628cce) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Show whether project config has been created during preflight, and let interactive publishes pause after first creating `.godotmaker/config.yaml` so users can edit model settings before the pipeline starts.
+
+- [`e649b4b`](https://github.com/RandallLiuXin/GodotMakerApp/commit/e649b4b5f7fc1b8a93a19d01cda943441351ee84) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Echo upstream role model config during preflight.
+
+- [`5ea064b`](https://github.com/RandallLiuXin/GodotMakerApp/commit/5ea064b9fafca920e4ebd407af6c27e331e52bff) Thanks [@RandallLiuXin](https://github.com/RandallLiuXin)! - Prepare the CLI for npm publishing with a bundled, minified, obfuscated runtime and a publish-ready release workflow.
+
+## 0.1.0
+
+Initial baseline. Consolidates pre-changesets internal history (former 0.1.0–0.3.0 releases). See git log for the full evolution and the frozen root `CHANGELOG.md` for narrative pre-baseline release notes.
+
+### Capabilities at 0.1.0
+
+- Ink-based 3-panel TUI (Header / Pipeline / Session) driving the core state machine (R-301).
+- Slash commands: `/help`, `/quit`, `/start`, `/pause`, `/peek`, `/usage` with always-on input bar and overlay panel (R-303 / R-310 / R-312 / R-314).
+- Live slash-command suggestion popup with Tab-complete and Enter-execute (R-315).
+- Preflight panel + `/start` IDLE flow: cli mounts idle, waits for `/start` before running; `--auto-start` and non-TTY stdin auto-fire (R-304 / R-310).
+- Graceful pause via `/pause` (typed) or Ctrl-C (unmount cleanup); resume target written to `pipeline_state.json` for `/start` to pick up (R-310).
+- Token / cost / duration tracking surfaced live in the Header and detailed in the `/usage` overlay (R-314).
+- Diagnostic `/peek` overlay: cross-stage tool history with per-tool status pairing (✓ / ✗ / …), full args, result preview, render hygiene for ANSI / control bytes (R-312 / R-318).
+- Persistent rolling JSONL session logger at `~/.godotmaker/cli/logs/`, levels driven by `cli-config.yaml` (R-306).
+- Interactive-handoff ASCII banner printed at TTY handoff so the operator keeps stage / iter context while the cli TUI is unmounted (R-308).
+- Bilingual cli docs (`README.zh-CN.md`, `GETTING_STARTED.zh-CN.md`).

package/GETTING_STARTED.md

@@ -0,0 +1,400 @@
+# Getting Started with godotmaker-cli
+
+> 中文版：[GETTING_STARTED.zh-CN.md](./GETTING_STARTED.zh-CN.md)  ·  Reference: [README.md](./README.md)
+
+This guide walks you through your first end-to-end testing session.
+It assumes you've never run the tool before. By the end you'll have:
+
+1. Verified your environment without burning agent tokens.
+2. Generated a complete Godot project from a one-line idea.
+3. Touched all the failure / resume / interactive paths so nothing
+   surprises you in real use.
+
+If anything in here doesn't match what you see, capture
+`.godotmaker/` and the terminal output and file an issue.
+
+---
+
+## 0. Prerequisites
+
+| Tool | Version | How to verify |
+|---|---|---|
+| Node.js | 22+ | `node --version` |
+| Claude Code CLI or Codex CLI | latest | `claude --version` or `codex --version` |
+| Godot | 4.x | `godot --version` (or open the GUI) |
+
+The selected agent binary must be on your PATH **and authenticated**. If
+the version probe fails, install the selected agent CLI and reopen your shell.
+
+The CLI auto-publishes the GodotMaker framework (`/gm-scaffold`,
+`/gm-gdd`, `/gm-asset`, `/gm-build`, `/gm-verify`, `/gm-evaluate`,
+`/gm-fixgap`, `/gm-accept`, `/gm-finalize`) into each project during
+preflight, pinned to the version in `cliConfig.pinnedGodotmakerVersion`
+(currently `v0.5.0`).
+
+### Install or run the CLI
+
+Use `npx` for one-off runs, or install the binary globally if you will
+run several test sessions from different project folders:
+
+```bash
+npx godotmaker-cli --help
+# or
+npm install -g godotmaker-cli
+```
+
+The rest of this guide uses the global `godotmaker-cli` command. If
+you choose `npx`, replace it with `npx godotmaker-cli`.
+
+For local development from a checkout, build first and optionally link
+the workspace package:
+
+```bash
+cd /path/to/GodotMakerApp
+npm install
+npm run build
+npm link -w godotmaker-cli     # optional: registers `godotmaker-cli` system-wide
+godotmaker-cli --help
+```
+
+Confirm tests + types are green before changing repo code (stay in the
+repo root for these):
+
+```bash
+npm test           # vitest, fast — does NOT type-check
+npm run typecheck  # tsc --noEmit on both workspaces, includes test files
+```
+
+Both should exit clean. `npm test` runs Vitest under esbuild (no type
+checking), so a separate typecheck pass is what catches missing
+fields and signature drift in test fixtures.
+
+> Need to remove the local development link later? `npm unlink -w
+> godotmaker-cli` from the same repo root.
+
+---
+
+## 1. Smoke test with `--dry-run` (no tokens)
+
+Dry-run walks the full 9-stage pipeline using local stubs. It
+proves your install is wired up without spending agent credits.
+
+```bash
+mkdir test-pong && cd test-pong
+godotmaker-cli --dry-run --auto-start
+```
+
+What you should see:
+
+- The TUI launches: header, 9-row pipeline panel, session view, input bar, footer.
+- A yellow `DRY-RUN` badge appears in the header area.
+- Each row turns ✓ as its stub runs (≈1 second total).
+- Footer turns green: `Pipeline complete. Press q or type /quit to exit.`
+
+Files that should now exist:
+
+```
+test-pong/
+├── project.godot              # stub project
+├── GDD.md                     # stub design doc
+└── .godotmaker/
+    ├── pipeline_state.json    # status: completed
+    ├── stage.jsonl            # 9 events, one per stage
+    ├── evaluation.json        # result: approve
+    └── final_report.json
+```
+
+Press `q` or type `/quit` and Enter to exit.
+
+**If any stage halts here, stop and fix it before going further.**
+A dry-run failure means the wiring itself is broken.
+
+### Try the slash commands while still on the dry-run output
+
+Re-run dry-run without `--auto-start`, type `/start`, and before pressing `q`:
+
+- Type `/help` Enter — overlay listing all commands and the hotkeys appears.
+- Press any key to dismiss it.
+- Look at the Header at the top of the TUI — it shows current stage
+  (in PipelinePanel below), iteration N/maxN, build try N/maxN, and
+  the last evaluation cell (`✓ approved` in green for the dry-run
+  happy path). No overlay needed; this info is always on screen
+  during a run.
+- Type `/peek` Enter — under dry-run there is no live non-interactive
+  agent session to tail, so you'll see `no active agent session to tail.`
+  as a yellow message. In a real run during a non-interactive state
+  (build / verify / etc.), this opens a 1 Hz live tail of the active
+  state's stream-json + stderr; press any key to dismiss.
+- Type just `/` (no command) — a popup appears under the input bar
+  listing every slash command. **Up / Down** navigate (wrap-around),
+  **Tab** completes the highlighted command into the buffer, **Enter**
+  auto-completes-and-runs it (so `/h` + Enter executes `/help`).
+  Matching is case-sensitive — `/H` shows nothing.
+- Type `/foo` Enter — popup hides (no matches), yellow message:
+  `unknown command: /foo — try /help`.
+- Type any character — message clears.
+- Type `/quit` Enter — exits in any state (during a run, also aborts
+  the active selected agent child and writes a resume checkpoint to
+  `pipeline_state.json`; the next launch can `/start` to continue).
+
+---
+
+## 2. Real first run (one authenticated agent account, ~10–30 min)
+
+```bash
+mkdir my-pong && cd my-pong
+godotmaker-cli
+```
+
+The TUI opens in `idle` after preflight. Type `/start` to begin. If
+you need unattended behavior, pass `--auto-start`.
+
+Walk the 9 stages. Three of them are interactive — TUI hands the
+terminal off to a selected-agent session, so you'll see that agent's own UI
+for those.
+
+### 2a. scaffold (interactive)
+
+The selected agent asks for:
+- **game name** — e.g. `Pong`
+- **perspective** — `2D` or `3D`
+
+When `/gm-scaffold` finishes, the selected agent exits. The TUI re-mounts. The
+scaffold row turns ✓.
+
+If `project.godot` did not appear in your project root, the run
+halts. Recheck selected agent authentication.
+
+### 2b. gdd (interactive)
+
+The selected agent conducts a brief design interview (mechanics, win condition,
+…). Answer succinctly. `GDD.md` lands in your project root.
+
+### 2c. asset (auto, ~30 s – 2 min)
+
+Runs in the background. The session view streams `[tool] Bash`,
+`[tool] Read`, `[agent] ...` lines as the selected agent works. No input needed.
+
+### 2d. build (auto, longest stage)
+
+This is where the actual scenes / scripts get written. Default
+idle-timeout is 900 s. This is not a wall-clock cap: it only fires
+when the selected agent produces no stdout/stderr for that long. Watch
+the session view to gauge progress; if nothing moves for 5+ minutes,
+something may be stalled. `Ctrl-C` to abort.
+
+### 2e. verify (auto)
+
+Read-only check. Pipeline routes based on a freshness-checked
+`stage.jsonl` event:
+- pass → evaluate
+- fail → build (counts toward `maxBuildAttempts`)
+
+### 2f. evaluate (auto)
+
+Writes `.godotmaker/evaluation.json` with a binary
+`result: "approve" | "reject"` verdict plus categorized issue
+arrays. Look at the Header's `eval` cell — `✓ approved` in green
+on approve, `✗ Nc+Mm` in yellow on reject (N/M are critical /
+major issue counts).
+
+Routing:
+- `verdict === "approve"` → **accept**
+- `verdict === "reject"` AND max iterations reached → **accept**
+  (the agent escape hatch: `/gm-accept` triages and either OKs the
+  build or recommends a different SKILL — see 0509 e2e test session)
+- otherwise → **fixgap**
+
+### 2g. fixgap (auto, only when retrying)
+
+Reads the latest evaluation, feeds it as guidance into a
+build-style session, then re-enters verify. This is one full loop
+of the Generator-Evaluator pattern.
+
+### 2h. accept (interactive)
+
+The selected agent shows you the project state and the evaluation, then asks
+for a decision:
+- `accept` → finalize → done
+- `fix` → another fixgap loop with your free-form feedback
+- `done` → pause the pipeline at accept; **next launch resumes here**
+
+### 2i. finalize (auto)
+
+`/gm-finalize` writes `final_report.json` with a consistency check
+and archive summary. Pipeline complete; press `q`.
+
+### Open the result in Godot
+
+```bash
+godot --path .
+# or just: godot project.godot
+```
+
+You should be able to launch the project. If it crashes on launch,
+the build was technically correct but functionally broken — that's
+material for `/gm-fixgap` next iteration. Re-run with `--max-iterations`
+bumped if you want more loops.
+
+---
+
+## 3. Test the resume path
+
+Resume is the most-used real-world path. Verify it works:
+
+```bash
+# in a project that paused at accept (you picked `done`):
+godotmaker-cli
+```
+
+What to confirm:
+- TUI re-launches; rows that already finished show ✓ from frame 0.
+- Header shows the right `iter N/maxN`.
+- Header's `eval` cell shows the previous run's verdict immediately
+  (not `--`) — this is the P1 fix: `restoreContext` reads
+  `evaluation.json` on resume.
+
+Then test the destructive path:
+
+```bash
+godotmaker-cli --fresh
+```
+
+`.godotmaker/` clears (state, stage events, evaluation, report);
+your `GDD.md`, scenes, scripts are untouched. Pipeline restarts at
+scaffold.
+
+---
+
+## 4. Test interactive handoff failure modes
+
+Edge cases worth poking:
+
+### 4a. `Ctrl-C` during an interactive stage
+While inside `/gm-scaffold` (or `/gm-gdd` / `/gm-accept`) hit
+`Ctrl-C`. The handed-off selected-agent session exits, control returns to
+the cli, the unmount-cleanup hook writes a resume checkpoint, and
+the cli exits. The next launch can `/start` to resume that state.
+
+### 4b. `Ctrl-C` during an auto stage
+Hit `Ctrl-C` while `build` or `evaluate` is running. Ink unmounts
+the cli; the unmount-cleanup hook aborts the in-flight selected agent child
+and writes a paused checkpoint to `pipeline_state.json`. The next
+launch can `/start` to resume from the interrupted state. If you
+want to pause WITHOUT exiting (cli stays mounted, `/start` resumes
+immediately), type `/pause` instead.
+
+### 4c. mid-run `q`
+Try `q` while the pipeline is running. **Nothing happens** — `q` is
+intentionally gated to non-running statuses (`idle` / `paused` /
+`finished` / `failed`); the keystroke just falls through to the
+input buffer. To exit during a run use `Ctrl-C` or `/quit` (both
+abort the selected agent + write a checkpoint); to pause without exiting use
+`/pause`. The footer should remind you `running… (/pause to pause,
+Ctrl-C to exit; /help for commands)`.
+
+### 4d. crash recovery
+This is hard to trigger on purpose, but if a state throws an
+unexpected error, `run.tsx` catches it, `unmountForCrash()` tears
+Ink down cleanly (terminal returns to cooked mode), and the stack
+trace lands on stderr. Test by hand only if you have a way to
+inject a throw.
+
+---
+
+## 5. Configuration
+
+### CLI flags (precedence: CLI > config.yaml > defaults)
+
+```bash
+node ... --agent codex --max-iterations 5 --model gpt-5.5
+```
+
+Use `--agent claude-code` or `--agent codex` to select the agent runtime
+for one launch without changing project or global config. The CLI resolves
+agent selection in this order: command-line flag, project config, CLI-global
+config, then the default `claude-code`.
+Default build / evaluate models are agent-aware: Claude Code uses `opus`,
+while Codex uses `gpt-5.5`.
+
+### Per-project config
+
+Create `.godotmaker/config.yaml`:
+
+```yaml
+agent: codex
+pipeline:
+  maxIterations: 5
+  maxBuildAttempts: 3
+  buildModel: gpt-5.5
+  evalModel: gpt-5.5
+```
+
+Idle-timeout for spawned non-interactive agent sessions is configured globally
+via `~/.godotmaker/cli/config.yaml` (`idle_timeout_seconds`, default
+900) — not per-project, because every workspace shares the same
+machine-level definition of "the selected agent is wedged".
+
+### Environment variables
+
+- `GMA_DRY_RUN=1` — same effect as `--dry-run`. Useful for CI or one-off scripts.
+
+---
+
+## 6. What to capture in a bug report
+
+```
+.godotmaker/pipeline_state.json
+.godotmaker/stage.jsonl
+.godotmaker/evaluation.json    # if it exists
+.godotmaker/final_report.json  # if it exists
+project.godot                   # if it exists
+GDD.md                          # if it exists
+```
+
+Plus the terminal output if you can scroll back. The TUI streams
+real-time, so the post-mortem comes from these files + your
+recollection of which stage halted.
+
+---
+
+## 7. Cheat sheet
+
+```bash
+# first time, verify install
+godotmaker-cli --dry-run --auto-start
+
+# real run
+godotmaker-cli
+# then type /start in the TUI
+
+# resume after a pause
+godotmaker-cli
+
+# blow it all up and start over
+godotmaker-cli --fresh
+
+# more retries
+godotmaker-cli --max-iterations 5
+
+# inside the TUI
+/start    # begin (or resume after a pause) the pipeline
+/pause    # pause the running pipeline (cli stays mounted; /start to resume)
+/refresh  # reset iteration / build budget (idle / paused / finished / failed; /pause first if running)
+/help     # commands list
+/peek     # live tail of the active agent session (non-interactive states only)
+/usage    # token / cost / time totals (this run + project lifetime)
+/quit     # exit in any state; during a run also aborts the selected agent + writes a resume checkpoint
+q         # exit, but only when not running (input bar empty); same checkpoint path as /quit
+Ctrl-C    # exit in any state; during a run also aborts the selected agent + writes a resume checkpoint
+Esc       # clear input buffer
+```
+
+---
+
+## Where to go next
+
+- Reference docs: [`README.md`](./README.md)
+- Design / internals: [`../docs/design/cli-design.md`](../docs/design/cli-design.md)
+- Roadmap: [`../ROADMAP.md`](../ROADMAP.md)
+- Upstream skill source: [GodotMaker](https://github.com/RandallLiuXin/GodotMaker)