triss-coworker 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -7,6 +7,58 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.26.0] — 2026-07-27
+
+### Added
+
+- **Kimi (Moonshot AI) as a first-class inference provider.** `triss ask` and
+  `triss review` accept `--provider kimi` (aliases `moonshot`, `moonshotai`;
+  also the `provider` field on the `triss_ask` / `triss_review` MCP tools), using
+  `MOONSHOT_API_KEY` against the OpenAI-compatible
+  `https://api.moonshot.ai/v1` endpoint. `--model pro` maps to `kimi-k3` —
+  Moonshot's flagship open-weights model (released 2026-07-16, weights
+  published 2026-07-26) — and `--model flash` to `kimi-k2.6`, the cheapest
+  current-generation model. Model ids are passed bare: Kimi has a single
+  endpoint, so there is no prefix grammar and no endpoint auto-correction.
+  `TRISS_KIMI_BASE_URL` points the route at a different host (e.g. the
+  China-mainland `api.moonshot.cn`). Both settings live in the reloadable
+  provider snapshot, so a long-lived MCP server picks up edits without a
+  restart.
+- **Kimi in `triss coder`.** `triss coder init --provider moonshot` sets up
+  pay-as-you-go `moonshotai/*` models (default main `moonshotai/kimi-k2.7-code`,
+  small `moonshotai/kimi-k2.6`), and `--provider kimi-for-coding` sets up the
+  flat-rate Kimi for Coding subscription (`kimi-for-coding/k3` — Kimi K3 —
+  with `KIMI_API_KEY`). Unlike Z.AI there is no plan probe: the two Kimi plans
+  use different credential envs, so the provider choice already names the
+  endpoint. Runs forward only the key the resolved model needs; a Kimi-only
+  machine needs no `ZHIPU_API_KEY`. The `moonshotai-cn/*` prefix is recognised
+  for China-mainland pins. The crush engine remains Z.AI-only and now rejects
+  any non-GLM model override explicitly.
+- `triss status` / `triss_status` print a Kimi routing block (key presence,
+  resolved endpoint and its source, preset models), and
+  `triss_coder_run` / `triss_coder_status` surface once any provider
+  credential is set — `ZHIPU_API_KEY`, `OPENCODE_API_KEY`,
+  `MOONSHOT_API_KEY`, or `KIMI_API_KEY`.
+- Kimi list prices (fetched 2026-07-27 from platform.kimi.ai) ship built-in
+  for `kimi-k3`, `kimi-k2.7-code`, `kimi-k2.7-code-highspeed`, and
+  `kimi-k2.6`, matched whether the id is logged bare (ask/review) or under
+  opencode's `moonshotai/` / `moonshotai-cn/` prefix (coder runs).
+  `kimi-for-coding/*` subscription calls are accounted as known `$0` — the
+  plan meters by quota, like the Z.AI Coding Plan.
+
+### Changed
+
+- The opencode engine pin was bumped from 1.17.18 to 1.18.7 (2026-07-27
+  release; the 1.18.x line is bugfix/Desktop work with no `run` CLI changes,
+  and 1.18.4 specifically improved Kimi model handling).
+- The `coder` row in `triss status` is labelled `coder` (previously
+  `GLM/coder`) now that it fronts GLM, Kimi, and OpenCode Zen credentials.
+- The npm tarball no longer ships `docs/promo/` (marketing drafts); the
+  package `files` list excludes it explicitly.
+- A bare `triss coder run` that fails on a missing `ZHIPU_API_KEY` now names
+  the working `--model` path when another provider's key (Zen/Kimi) is
+  configured, and Kimi 429 responses carry a rate-limit/balance hint.
+
 ## [0.25.0] — 2026-07-27
 
 ### Added
@@ -728,7 +780,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release of `triss-coworker`.
 
-[Unreleased]: https://github.com/ayleen/triss-coworker/compare/v0.24.1...HEAD
+[Unreleased]: https://github.com/ayleen/triss-coworker/compare/v0.26.0...HEAD
+[0.26.0]: https://github.com/ayleen/triss-coworker/compare/v0.25.0...v0.26.0
+[0.25.0]: https://github.com/ayleen/triss-coworker/compare/v0.24.2...v0.25.0
+[0.24.2]: https://github.com/ayleen/triss-coworker/compare/v0.24.1...v0.24.2
 [0.24.1]: https://github.com/ayleen/triss-coworker/compare/v0.24.0...v0.24.1
 [0.24.0]: https://github.com/ayleen/triss-coworker/compare/v0.23.0...v0.24.0
 [0.23.0]: https://github.com/ayleen/triss-coworker/compare/v0.22.4...v0.23.0

package/README.md

@@ -236,10 +236,12 @@ The exposed tool set is **filtered by configured credentials**:
 - **`triss_linear_*`** when `LINEAR_API_KEY` is set.
 - **`triss_github_*`** when `GITHUB_TOKEN` is set (or `gh` CLI logged in).
 - **`triss_gitlab_*`** when `GITLAB_TOKEN` is set.
-- **`triss_coder_run` + `triss_coder_status`** when `ZHIPU_API_KEY` is set
+- **`triss_coder_run` + `triss_coder_status`** when any coder provider key is
+  set — `ZHIPU_API_KEY` (Z.AI GLM), `OPENCODE_API_KEY` (OpenCode Zen),
+  `MOONSHOT_API_KEY` (Moonshot Kimi), or `KIMI_API_KEY` (Kimi for Coding)
   (setup: `triss coder init`). `triss_coder_run` takes an optional `engine`
   (`opencode` default, or `crush`); its timeout defaults to
-  1500s (25 min) over MCP, above the CLI's 900s, since GLM runs are
+  1500s (25 min) over MCP, above the CLI's 900s, since coding runs are
   expected to be long; override per call via the `timeout` arg. For
   runs that may exceed it, use `triss coder run` on the CLI instead.
 
@@ -269,8 +271,8 @@ and writing**.
 | `triss review`     | Code review on current branch or a PR (diff + linked ticket) | The agent reading the whole diff |
 | `triss commit-msg` | Generates a commit message from staged diff           | Hand-writing or copy-pasting from web LLMs |
 | `triss usage`      | Cumulative cost / token usage with per-project breakdown | Squinting at stderr after each call |
-| `triss coder init` | Sets up a coding agent (default `opencode` engine; `--engine crush` for crush): provider key (Z.AI GLM, or `--provider opencode-zen` for free OpenCode Zen models like `hy3`), `opencode.json` / crush models + `permissions.run` policy, agent templates. Blocks (non-zero) on an unsafe existing `opencode.json` — missing deny-first bash policy (override with `--allow-unsafe-bash`) or a stale/cross-provider `small_model` | Manually installing/configuring opencode |
-| `triss coder run` | Spawns the GLM coding agent and prints one JSON envelope (`--engine opencode\|crush`; `--isolate` for a disposable worktree — opencode defaults to isolate-OFF, crush defaults to isolate-ON; crush adds opt-in `--restrict`/`--no-restrict` for its CLI allowlist). **POSIX only** (macOS/Linux) — refuses to run on Windows. | Manually driving `opencode run` and parsing its ndjson stream |
+| `triss coder init` | Sets up a coding agent (default `opencode` engine; `--engine crush` for crush): provider key (Z.AI GLM default; `--provider opencode-zen` for free OpenCode Zen models like `hy3`; `--provider moonshot` for Kimi pay-as-you-go; `--provider kimi-for-coding` for the Kimi subscription), `opencode.json` / crush models + `permissions.run` policy, agent templates. Blocks (non-zero) on an unsafe existing `opencode.json` — missing deny-first bash policy (override with `--allow-unsafe-bash`) or a stale/cross-provider `small_model` | Manually installing/configuring opencode |
+| `triss coder run` | Spawns the coding agent (GLM, Kimi, or Zen models) and prints one JSON envelope (`--engine opencode\|crush`; `--isolate` for a disposable worktree — opencode defaults to isolate-OFF, crush defaults to isolate-ON; crush adds opt-in `--restrict`/`--no-restrict` for its CLI allowlist). **POSIX only** (macOS/Linux) — refuses to run on Windows. | Manually driving `opencode run` and parsing its ndjson stream |
 | `triss coder clean` | Removes finished `.triss/wt` isolation worktrees (`--all` forces all) | Manually finding and deleting stale git worktrees |
 | `triss init`       | Drops a tiny (~15 line) delegation block into `CLAUDE.md` / `AGENTS.md` | Hand-writing routing rules         |
 | `triss agent-help` | Prints the full delegation cookbook on demand (the nano block points here) | A 200-line CLAUDE.md that always loads |
@@ -292,6 +294,10 @@ triss ask --paths "src/**/*.ts" \
 triss ask --paths "src/**/*.ts" \
           --question "Find SQL injection risks" \
           --provider glm --model pro
+
+triss ask --paths "src/**/*.ts" \
+          --question "Find SQL injection risks" \
+          --provider kimi --model pro    # Kimi K3 via MOONSHOT_API_KEY
 ```
 
 Typical output is a focused answer with cited file paths, not a raw file dump.
@@ -404,6 +410,7 @@ triss review 123             # GitHub PR #123 (requires `gh` CLI)
 triss review --base develop  # explicit base
 triss review --skip-issue    # don't try ticket lookup
 triss review --provider glm  # same review flow, one-shot GLM inference
+triss review --provider kimi # …or Kimi (pro preset = kimi-k3)
 ```
 
 Defaults to the `pro` preset because review needs reasoning. Output is
@@ -443,9 +450,10 @@ default timeout, configurable via `--timeout <ms>`.
 
 ### `triss coder`
 
-Delegates an implementation task to a GLM coding agent (the `opencode`
-engine by default; `crush` is an alternative — see **Engines** below)
-instead of the primary model writing the code itself.
+Delegates an implementation task to a cheap coding agent — GLM, Kimi, or
+OpenCode Zen models (the `opencode` engine by default; `crush` is an
+alternative — see **Engines** below) instead of the primary model writing
+the code itself.
 
 ```bash
 triss coder init                                  # once: key, opencode.json, agent templates
@@ -456,11 +464,17 @@ triss coder clean                                 # remove finished isolation wo
 ```
 
 `triss coder init` first asks which provider to configure — **Z.AI GLM**
-(default) or **OpenCode Zen** (`--provider opencode-zen`, free models incl.
-Hunyuan `hy3`). For Z.AI it probes which plan your key works with (subscription
-vs. pay-as-you-go) and writes the matching model prefix; for Zen it saves an
-`OPENCODE_API_KEY` and writes an `opencode/<id>` model. Either way it lets you
-pick the model interactively. See the **Providers** section below and
+(default), **OpenCode Zen** (`--provider opencode-zen`, free models incl.
+Hunyuan `hy3`), **Moonshot Kimi** (`--provider moonshot`, pay-as-you-go
+`moonshotai/*` models like `kimi-k2.7-code`), or **Kimi for Coding**
+(`--provider kimi-for-coding`, the flat-rate subscription serving Kimi K3).
+For Z.AI it probes which plan your key works with (subscription vs.
+pay-as-you-go) and writes the matching model prefix; for Zen it saves an
+`OPENCODE_API_KEY` and writes an `opencode/<id>` model; the two Kimi
+providers need no probe at all — their plans use different keys
+(`MOONSHOT_API_KEY` vs `KIMI_API_KEY`), so the choice already names the
+endpoint. Either way it lets you pick the model interactively. See the
+**Providers** section below and
 [docs/opencode-zen.md](docs/opencode-zen.md) for the OpenCode Zen deep‑dive.
 
 Prints one JSON envelope to stdout — `files_changed`, `diff_stat`, and
@@ -494,9 +508,14 @@ natively; triss also forwards it as `ZAI_API_KEY` for older binaries; see
 
 **Providers** — the `opencode` engine isn't limited to Z.AI. The required
 API key follows the model's `<provider>/` prefix: `zai-coding-plan/*` and
-`zai/*` (GLM) use `ZHIPU_API_KEY`, while `opencode/*` models — served free by
+`zai/*` (GLM) use `ZHIPU_API_KEY`; `opencode/*` models — served free by
 [OpenCode Zen](https://opencode.ai/docs/zen/), e.g. **`opencode/hy3-free`**
-(Tencent Hunyuan 3) — use `OPENCODE_API_KEY`. To point coder at a Zen model:
+(Tencent Hunyuan 3) — use `OPENCODE_API_KEY`; `moonshotai/*` (and the
+China-mainland `moonshotai-cn/*`) Kimi models use `MOONSHOT_API_KEY`; and
+`kimi-for-coding/*` models — the flat-rate
+[Kimi for Coding](https://www.kimi.com/code/docs/en/) subscription, e.g.
+**`kimi-for-coding/k3`** (Kimi K3) — use `KIMI_API_KEY`. To point coder at
+a Zen model:
 
 ```bash
 triss coder init --provider opencode-zen         # guided: key + opencode.json
@@ -509,10 +528,21 @@ triss coder run "add input validation to /signup"
 triss coder run "..." --model opencode/hy3-free
 ```
 
+Kimi works the same way:
+
+```bash
+triss coder init --provider moonshot             # pay-as-you-go: kimi-k2.7-code default
+triss coder init --provider kimi-for-coding      # subscription: Kimi K3 on a flat plan
+# …or per-run, without changing the default:
+triss coder run "..." --model moonshotai/kimi-k3
+triss coder run "..." --model kimi-for-coding/k3
+```
+
 `triss coder run` passes the resolved model to opencode with `--model` and
 forwards only the key that model needs, so a Zen run works with
-`OPENCODE_API_KEY` alone — no Z.AI key required. The deny-first `opencode.json`
-bash policy applies to Zen runs too. Any Zen model id works via
+`OPENCODE_API_KEY` alone and a Kimi run with `MOONSHOT_API_KEY` /
+`KIMI_API_KEY` alone — no Z.AI key required. The deny-first `opencode.json`
+bash policy applies to every provider. Any Zen model id works via
 `TRISS_CODER_MODEL=opencode/<id>` / `--model`, not just the free ones the
 picker lists. (The `crush` engine speaks Z.AI only.) Full details, the model
 catalogue, and every configuration path are in
@@ -595,13 +625,15 @@ requires an OpenAI-compatible chat-completions endpoint.
 
 You can also pass any model id directly: `--model deepseek-v4-pro`.
 
-`ask` and `review` can route the same one-shot request to GLM without invoking
-the agentic `coder` runtime:
+`ask` and `review` can route the same one-shot request to GLM or Kimi without
+invoking the agentic `coder` runtime:
 
 ```bash
 triss ask --paths ... --question "..." --provider glm --model flash
 triss review --provider glm --model pro
 triss review --provider glm --model zai/glm-5.2  # pay-as-you-go endpoint
+triss review --provider kimi                     # pro preset → kimi-k3
+triss ask --paths ... --question "..." --provider kimi --model flash  # kimi-k2.6
 ```
 
 For GLM, `pro` maps to `glm-5.2` on both endpoints, while `flash` — the cheap
@@ -620,6 +652,17 @@ it for the rest of the process. Pin it (`TRISS_CODER_MODEL=zai/glm-5.2`, or run
 `triss coder init`) to skip that probe. `triss status` shows the resolved
 endpoint, where it came from, and the presets it selects.
 
+For Kimi (`--provider kimi`, alias `moonshot`), `pro` maps to **`kimi-k3`** —
+Moonshot's flagship open-weights model ($3.00/$15.00 per 1M tokens, cache-hit
+input $0.30) — and `flash` to `kimi-k2.6` ($0.95/$4.00, cache-hit $0.16), the
+cheapest current-generation model on the platform. `MOONSHOT_API_KEY` is
+reused from the coder setup, there is a single OpenAI-compatible endpoint
+(`https://api.moonshot.ai/v1`; set `TRISS_KIMI_BASE_URL` for the
+China-mainland `api.moonshot.cn`), and model ids are passed bare —
+`--model kimi-k2.7-code`. The Kimi for Coding subscription is coder-only: its
+endpoint speaks the Anthropic protocol, which ask/review's OpenAI client
+cannot use.
+
 `triss coder` stays separate because it is an agent runtime with tools,
 sessions, and worktree isolation.
 
@@ -631,12 +674,17 @@ triss config set TRISS_WORKER_API_KEY                     # masked prompt
 # That's it — BASE_URL / FLASH / PRO use the current DeepSeek V4 defaults.
 ```
 
-#### Kimi / Moonshot
+#### Kimi / Moonshot (first-class)
+```bash
+triss config set MOONSHOT_API_KEY                         # masked prompt
+triss ask --provider kimi ...                             # flash=kimi-k2.6, pro=kimi-k3
+```
+Or replace the worker entirely (keeps `--provider` free for something else):
 ```bash
 triss config set TRISS_WORKER_API_KEY $MOONSHOT_API_KEY
 triss config set TRISS_WORKER_BASE_URL https://api.moonshot.ai/v1
-triss config set TRISS_WORKER_FLASH_MODEL kimi-k2.5
-triss config set TRISS_WORKER_PRO_MODEL kimi-k2.5
+triss config set TRISS_WORKER_FLASH_MODEL kimi-k2.6
+triss config set TRISS_WORKER_PRO_MODEL kimi-k3
 ```
 
 #### Ollama (local, free)

package/bin/triss.js

@@ -66,12 +66,12 @@ program
 
 program
   .command('ask')
-  .description('Delegate bulk reading to the configured worker or GLM; returns a structured summary')
+  .description('Delegate bulk reading to the configured worker, GLM, or Kimi; returns a structured summary')
   .option('-p, --paths <paths...>', 'files or globs to read')
   .option('-u, --urls <urls...>', 'http(s) URLs to fetch and convert to markdown')
   .option('--stdin', 'read piped stdin as an additional source (for `cmd | triss ask --stdin ...`)')
   .requiredOption('-q, --question <text>', 'question to answer about the corpus')
-  .option('--provider <name>', 'inference provider: worker (default), deepseek (alias), or glm')
+  .option('--provider <name>', 'inference provider: worker (default), deepseek (alias), glm, or kimi (alias: moonshot)')
   .option('-m, --model <name>', 'model preset (flash | pro) or full model id')
   .option('--max-tokens <n>', 'token budget for reasoning + answer', (v) => parseInt(v, 10), 8192)
   .option('--system <text>', 'override the system prompt')
@@ -131,11 +131,11 @@ program
 
 program
   .command('review [pr]')
-  .description('Code review via the configured worker or GLM. No arg: current branch vs default base. With <pr>: GitHub PR via gh.')
+  .description('Code review via the configured worker, GLM, or Kimi. No arg: current branch vs default base. With <pr>: GitHub PR via gh.')
   .option('-b, --base <branch>', 'compare against this branch (default: auto-detect origin/HEAD or main/master/develop)')
   .option('--skip-issue', "don't try to look up a Jira/Linear ticket from the branch/PR title")
   .option('-q, --question <text>', 'override the default review question')
-  .option('--provider <name>', 'inference provider: worker (default), deepseek (alias), or glm')
+  .option('--provider <name>', 'inference provider: worker (default), deepseek (alias), glm, or kimi (alias: moonshot)')
   .option('-m, --model <name>', 'model preset (flash | pro) or full model id (default: pro)')
   .option('--max-tokens <n>', 'token budget for the review (default 8192)')
   .option('--no-stream', 'disable streaming output')
@@ -235,13 +235,13 @@ coder
   .option('-g, --global', 'save to the global scope (~/.config/triss/.env, ~/.config/opencode/)')
   .option('-l, --local', 'save to the project scope (./.triss.env, ./opencode.json)')
   .option('--engine <name>', 'coding engine to configure: opencode (default) or crush')
-  .option('--provider <name>', 'opencode engine model provider: zai (Z.AI GLM, default) or opencode-zen (free models incl. hy3)')
+  .option('--provider <name>', 'opencode engine model provider: zai (Z.AI GLM, default), opencode-zen (free models incl. hy3), moonshot (Kimi pay-as-you-go), or kimi-for-coding (subscription)')
   .option('--allow-unsafe-bash', 'proceed even if an existing opencode.json has no deny-first bash policy (the agent runs with --auto)')
   .action(wrap(runCoderInit));
 
 coder
   .command('run [prompt]')
-  .description('Spawn a GLM coding agent (opencode default, or --engine crush) and print a JSON envelope to stdout')
+  .description('Spawn a coding agent — GLM, Kimi, or Zen models (opencode default, or --engine crush) — and print a JSON envelope to stdout')
   .option('--engine <name>', 'coding engine: opencode (default) or crush')
   .option('--session <id>', 'triss-side session slug, mapped to a real opencode session id in .triss/sessions.json')
   .option('--continue', 'continue the most recent opencode session (maps to opencode --continue)')

package/docs/configuration.md

@@ -122,7 +122,7 @@ Removes a variable.
 | `worker`   | `TRISS_WORKER_API_KEY`, `TRISS_WORKER_BASE_URL`, `TRISS_WORKER_FLASH_MODEL`, `TRISS_WORKER_PRO_MODEL` | only `TRISS_WORKER_API_KEY` is required |
 | `jira`     | `ATLASSIAN_BASE_URL`, `ATLASSIAN_EMAIL`, `ATLASSIAN_API_TOKEN`           | all three                                 |
 | `linear`   | `LINEAR_API_KEY`, `LINEAR_API_URL`                                       | only `LINEAR_API_KEY` is required         |
-| `coder`    | `ZHIPU_API_KEY`, `OPENCODE_API_KEY` (setup: `triss coder init` — engine, `opencode.json`, agent templates) | `ZHIPU_API_KEY` (Z.AI GLM); `OPENCODE_API_KEY` optional (OpenCode Zen, e.g. `opencode/hy3-free`) |
+| `coder`    | `ZHIPU_API_KEY`, `OPENCODE_API_KEY`, `MOONSHOT_API_KEY`, `KIMI_API_KEY` (setup: `triss coder init` — engine, `opencode.json`, agent templates) | `ZHIPU_API_KEY` (Z.AI GLM); the others optional — `OPENCODE_API_KEY` (OpenCode Zen), `MOONSHOT_API_KEY` (Moonshot Kimi), `KIMI_API_KEY` (Kimi for Coding) |
 
 When you add a new integration (see [extending.md](extending.md)), its
 `envVars` declaration is automatically picked up — no wizard changes needed.
@@ -250,15 +250,18 @@ self-hosted endpoints).
 | `TRISS_WORKER_PRO_MODEL`    | no       | `deepseek-v4-pro`                | Override the `pro` preset             |
 | `TRISS_DEFAULT_MODEL`   | no       | `flash`                          | Which preset is used when no `--model`|
 
-### GLM and coder
+### GLM, Kimi, and coder
 
 | Variable                        | Required | Default            | Notes                                     |
 | -------------------------------- | -------- | ------------------ | ------------------------------------------ |
 | `ZHIPU_API_KEY`                  | yes¹     | —                  | Z.AI API key for `ask`/`review --provider glm` and GLM coder models — <https://z.ai/manage-apikey/apikey-list> |
 | `OPENCODE_API_KEY`               | no¹      | —                  | OpenCode Zen key (opencode engine only) — unlocks `opencode/*` models like `opencode/hy3-free` — <https://opencode.ai/docs/zen/> |
-| `TRISS_CODER_MODEL`              | no       | `zai-coding-plan/glm-5.2`       | Resolved model, passed to opencode via `--model` (and written to `opencode.json` by `init`). Use `opencode/hy3-free` for OpenCode Zen |
+| `MOONSHOT_API_KEY`               | no¹      | —                  | Moonshot AI (Kimi) key for `ask`/`review --provider kimi` and `moonshotai/*` coder models — <https://platform.kimi.ai/console/api-keys> |
+| `KIMI_API_KEY`                   | no¹      | —                  | Kimi for Coding subscription key (opencode engine only) — unlocks `kimi-for-coding/*` models like `kimi-for-coding/k3` — <https://www.kimi.com/code/docs/en/> |
+| `TRISS_KIMI_BASE_URL`            | no       | `https://api.moonshot.ai/v1` | Endpoint for `--provider kimi` ask/review calls — set `https://api.moonshot.cn/v1` for a China-mainland key. Trailing slashes are stripped; a blank/degenerate value falls back to the default |
+| `TRISS_CODER_MODEL`              | no       | `zai-coding-plan/glm-5.2`       | Resolved model, passed to opencode via `--model` (and written to `opencode.json` by `init`). Use `opencode/hy3-free` for OpenCode Zen, `moonshotai/kimi-k2.7-code` for Moonshot, `kimi-for-coding/k3` for the Kimi subscription |
 | `TRISS_CODER_SMALL_MODEL`        | no       | `zai-coding-plan/glm-5-turbo`   | Small/fast model written to `opencode.json`|
-| `TRISS_CODER_OPENCODE_VERSION`   | no       | `1.17.18`           | Pin override for the `opencode-ai` npm install |
+| `TRISS_CODER_OPENCODE_VERSION`   | no       | `1.18.7`           | Pin override for the `opencode-ai` npm install |
 | `TRISS_CODER_ENGINE`             | no       | `opencode`          | Coding engine: `opencode` (default) or `crush` |
 | `TRISS_CODER_CRUSH_VERSION`      | no       | `0.1.6`             | Pin override for the `@phpcraftdream/crush` npm install (crush engine) |
 | `TRISS_CODER_CRUSH_RESTRICT`     | no       | unset (`0`)        | crush only — `1` opts INTO the CLI allowlist (`--restrict-run` + `--allow-bash`/`--allow-tool`, the only enforcement path that works today — crush 0.1.3 ignores the `permissions.run` config). Unset leaves crush unrestricted; crush then defaults to isolate-ON. CLI `--restrict`/`--no-restrict` overrides; crush.json `permissions.run.restrict` is the next fallback (forward-compat — currently inert) |
@@ -285,6 +288,16 @@ pay-as-you-go), and a prefix may carry a preset too — `zai/flash` means "the
 pay-as-you-go flash model". A bare model id inherits the prefix from
 `TRISS_CODER_MODEL`, then falls back to `zai-coding-plan`.
 
+`--provider kimi` (alias `moonshot`) works the same way with
+`MOONSHOT_API_KEY`: `pro` maps to `kimi-k3` (the flagship) and `flash` to
+`kimi-k2.6` (the cheapest current-generation model). Kimi has a single
+OpenAI-compatible endpoint, so model ids are passed bare — there is no
+prefix grammar and no endpoint auto-correction. `TRISS_KIMI_BASE_URL`
+points the route at a different host (e.g. `https://api.moonshot.cn/v1`).
+The Kimi for Coding subscription (`KIMI_API_KEY`) is coder-only — its
+endpoint speaks the Anthropic protocol, which ask/review's OpenAI client
+cannot use.
+
 **Endpoint auto-correction.** A Z.AI key carries no marker of which plan it
 belongs to, so an unpinned `zai-coding-plan` route is a guess. When nothing
 pinned the endpoint — no explicit prefix, no `TRISS_CODER_MODEL` — and the
@@ -301,16 +314,22 @@ preset models.
 ¹ **Credentials are provider-specific.** A run needs the one key its
 resolved model requires: `zai-coding-plan/*` and `zai/*` (GLM) need
 `ZHIPU_API_KEY`; `opencode/*` OpenCode Zen models (e.g. the free
-`opencode/hy3-free`) need `OPENCODE_API_KEY`. So `ZHIPU_API_KEY` is
+`opencode/hy3-free`) need `OPENCODE_API_KEY`; `moonshotai/*` and
+`moonshotai-cn/*` Kimi models need `MOONSHOT_API_KEY`; `kimi-for-coding/*`
+subscription models need `KIMI_API_KEY`. So `ZHIPU_API_KEY` is
 "required" only in the sense that it is the default provider's key — a
-zen-only setup runs on `OPENCODE_API_KEY` alone. `triss coder run` forwards
+zen-only setup runs on `OPENCODE_API_KEY` alone, a Kimi-only setup on its
+Kimi key alone. `triss coder run` forwards
 whichever key the model needs to the engine subprocess and gates on it
 before spawning. The `crush` engine speaks Z.AI only and always needs
-`ZHIPU_API_KEY`. `triss status` / `triss_coder_status` show both keys, and
-the coder MCP tools surface once **either** is set. Run
-`triss coder init --provider opencode-zen` to set up a Zen model interactively
-(key + `opencode.json`); full details are in
-[opencode-zen.md](opencode-zen.md).
+`ZHIPU_API_KEY`. `triss status` / `triss_coder_status` show all provider
+keys, and the coder MCP tools surface once **any** is set. Run
+`triss coder init --provider opencode-zen` (or `--provider moonshot` /
+`--provider kimi-for-coding`) to set up a non-GLM model interactively
+(key + `opencode.json`); Zen details are in
+[opencode-zen.md](opencode-zen.md). The two Kimi providers need no
+endpoint probe: their plans use different keys, so the provider choice
+already names the endpoint.
 
 **Engines.** `opencode` (default) enforces a deny-first per-command bash
 allowlist via `opencode.json` (curated safe commands only) that actually
@@ -405,10 +424,16 @@ canonical `zai/<model>` id and ship with Z.AI's published list prices for the
 models both endpoints advertise (`glm-4.5`, `glm-4.5-air`, `glm-4.6`,
 `glm-4.7`, `glm-5`, `glm-5-turbo`, `glm-5.1`, `glm-5.2`), so a PAYG cost is
 reported, not guessed. Override any of them the same way — `zai/glm-5.2` maps
-to `TRISS_PRICE_ZAI_GLM_5_2`. Subscription (`zai-coding-plan/*`) calls stay
+to `TRISS_PRICE_ZAI_GLM_5_2`. Kimi PAYG models ship with Moonshot's list
+prices (`kimi-k3`, `kimi-k2.7-code`, `kimi-k2.7-code-highspeed`,
+`kimi-k2.6`), matched whether the id is logged bare (ask/review) or with
+opencode's `moonshotai/` / `moonshotai-cn/` prefix (coder runs) — and a
+`TRISS_PRICE_<MODEL_ID>` override keyed on the bare id
+(`TRISS_PRICE_KIMI_K3`) covers both forms the same way.
+Subscription calls — `zai-coding-plan/*` and `kimi-for-coding/*` — stay
 `$0` because the plan meters by quota rather than tokens. Any model outside
-that catalogue — a newly released GLM id, `opencode/*` OpenCode Zen models —
-is explicitly unknown until you set its matching `TRISS_PRICE_<MODEL_ID>`
+those catalogues — a newly released GLM/Kimi id, `opencode/*` OpenCode Zen
+models — is explicitly unknown until you set its matching `TRISS_PRICE_<MODEL_ID>`
 override. Usage JSONL keeps `cost_usd` numeric for
 compatibility and marks these records with `cost_usd_known: false`; existing
 historical records are not relabelled.

package/docs/glm-clients.md

@@ -39,7 +39,9 @@ see §3). It **drives a local agent binary** and parses the one JSON
 envelope that binary prints. There are two such binaries ("engines"), both
 behind the same adapter interface. crush is always fed `ZHIPU_API_KEY`
 (bridged to `ZAI_API_KEY`); opencode is fed whichever key its resolved model
-needs — `ZHIPU_API_KEY` for GLM, `OPENCODE_API_KEY` for OpenCode Zen (§3).
+needs — `ZHIPU_API_KEY` for GLM, `OPENCODE_API_KEY` for OpenCode Zen (§3),
+`MOONSHOT_API_KEY` for `moonshotai/*` Kimi, `KIMI_API_KEY` for
+`kimi-for-coding/*`.
 
 ---
 
@@ -48,11 +50,11 @@ needs — `ZHIPU_API_KEY` for GLM, `OPENCODE_API_KEY` for OpenCode Zen (§3).
 | | **opencode** (engine #1, default) | **crush** (engine #2) |
 |---|---|---|
 | Select via | default, or `--engine opencode` | `--engine crush` / `TRISS_CODER_ENGINE=crush` |
-| npm package | `opencode-ai` (pinned `1.17.18`) | `@phpcraftdream/crush` (pinned `0.1.6`) |
+| npm package | `opencode-ai` (pinned `1.18.7`) | `@phpcraftdream/crush` (pinned `0.1.6`) |
 | Version pin env | `TRISS_CODER_OPENCODE_VERSION` | `TRISS_CODER_CRUSH_VERSION` |
-| Key it reads | `ZHIPU_API_KEY` (native); `OPENCODE_API_KEY` for `opencode/…` Zen models | `ZAI_API_KEY` (Triss bridges from `ZHIPU_API_KEY`; crush ≥0.1.1 also reads `ZHIPU_API_KEY` natively) |
-| Providers | Z.AI GLM (`zai-coding-plan/…`, `zai/…`) **and** OpenCode Zen (`opencode/…`, e.g. `opencode/hy3-free`) | Z.AI GLM only |
-| Provider config | `opencode.json` with a `zai-coding-plan/…` (or `zai/…`) model prefix; Zen models resolve via opencode's built-in `opencode` provider | `crush.json` `models` block (atoms `glm5_2` / `glm5_turbo`) |
+| Key it reads | `ZHIPU_API_KEY` (native); `OPENCODE_API_KEY` for `opencode/…` Zen models; `MOONSHOT_API_KEY` for `moonshotai/…`; `KIMI_API_KEY` for `kimi-for-coding/…` | `ZAI_API_KEY` (Triss bridges from `ZHIPU_API_KEY`; crush ≥0.1.1 also reads `ZHIPU_API_KEY` natively) |
+| Providers | Z.AI GLM (`zai-coding-plan/…`, `zai/…`), OpenCode Zen (`opencode/…`, e.g. `opencode/hy3-free`), **and** Moonshot Kimi (`moonshotai/…` PAYG, `kimi-for-coding/…` subscription — see README's Providers section) | Z.AI GLM only |
+| Provider config | `opencode.json` with a `zai-coding-plan/…` (or `zai/…`) model prefix; Zen/Kimi models resolve via opencode's built-in `opencode` / `moonshotai` / `kimi-for-coding` providers | `crush.json` `models` block (atoms `glm5_2` / `glm5_turbo`) |
 | Output | ndjson stream that Triss folds into one envelope | ONE JSON object at end-of-run — trivial last-line parse |
 | Sessions | slug → real `ses_…` id mapped in `.triss/sessions.json` | native get-or-create with the caller's arbitrary id — no map |
 | Safety model | **deny-first bash allowlist** in `opencode.json` (persistent, enforced) | config `permissions.run` seeded into `crush.json` for forward-compat, but **currently inert** — enforcement is opt-in via `--restrict`, which emits the allowlist as **CLI flags** (`--allow-bash`/`--allow-tool`). See §8 |
@@ -279,7 +281,7 @@ Read `files_changed` + `diff_stat` + `worktree` to know what to review.
 | `TRISS_CODER_ENGINE` | no | Default engine: `opencode` (default) or `crush`. |
 | `TRISS_CODER_MODEL` | no | Override main model, e.g. `zai-coding-plan/glm-5.2` (verbatim, prefix included). |
 | `TRISS_CODER_SMALL_MODEL` | no | Override small/fast model, e.g. `zai-coding-plan/glm-5-turbo`. |
-| `TRISS_CODER_OPENCODE_VERSION` | no | Pin a different `opencode-ai` npm version (default `1.17.18`). |
+| `TRISS_CODER_OPENCODE_VERSION` | no | Pin a different `opencode-ai` npm version (default `1.18.7`). |
 | `TRISS_CODER_CRUSH_VERSION` | no | Pin a different `@phpcraftdream/crush` version (default `0.1.6`). |
 | `TRISS_CODER_CRUSH_RESTRICT` | no | crush only: `1` opts INTO the allowlist (emits `--restrict-run` plus the `--allow-bash`/`--allow-tool` CLI flags — the only enforcement path that works today); unset/`0` leaves crush unrestricted (the default, paired with isolate-ON). Overridden per-run by `--restrict`/`--no-restrict`. |
 

package/docs/mcp.md

@@ -190,12 +190,14 @@ agent (or `claude /mcp`) lists tools, the new ones show up without
 restarting Claude Code. Replacing or removing an integration credential that
 is already loaded still requires restarting that MCP process.
 
-GLM calls have a narrower per-call refresh path: `triss_ask` and
+GLM and Kimi calls have a narrower per-call refresh path: `triss_ask` and
 `triss_review` with `provider: "glm"` re-read file-backed
-`TRISS_CODER_MODEL` and `ZHIPU_API_KEY` before each call. Edits and removals
-take effect without restarting the MCP server, except that values supplied by
-the parent environment continue to win. This does not change the existing
-`tools/list` refresh behaviour for other integrations.
+`TRISS_CODER_MODEL` and `ZHIPU_API_KEY` before each call, and with
+`provider: "kimi"` re-read `MOONSHOT_API_KEY` and `TRISS_KIMI_BASE_URL`.
+Edits and removals take effect without restarting the MCP server, except
+that values supplied by the parent environment continue to win. This does
+not change the existing `tools/list` refresh behaviour for other
+integrations.
 
 ## What tools are exposed
 
@@ -208,17 +210,19 @@ Core tools are always listed. Model calls default to the worker and require
 - `triss_chat` — bare prompt to the worker model
 - `triss_ask` — read files/URLs and answer a question; accepts an optional
   `provider` field: `worker` (default), `deepseek` (an alias for `worker`),
-  or `glm`
+  `glm`, or `kimi` (`moonshot` is an alias)
 - `triss_fetch` — fetch URL(s) as markdown, optional summary
 - `triss_review` — code review on current branch or a GitHub PR; accepts the
   same optional `provider` field as `triss_ask`
 - `triss_commit_msg` — generate a Conventional Commits message from staged diff
 - `triss_write` — generate boilerplate from a spec; with `target` writes the file (path-sandboxed), without `target` returns the content
 - `triss_status` — current configuration and integration readiness, including a
-  GLM block: whether `ZHIPU_API_KEY` is set, the endpoint a `provider: "glm"`
-  call resolves to, what selected it, and the preset models. A GLM-only server
-  has no worker key, so the worker rows say `(missing)` while GLM calls work —
-  the two are labelled separately for that reason.
+  GLM block — whether `ZHIPU_API_KEY` is set, the endpoint a `provider: "glm"`
+  call resolves to, what selected it, and the preset models — and a Kimi block
+  (`MOONSHOT_API_KEY` presence, the resolved endpoint, presets). A GLM- or
+  Kimi-only server has no worker key, so the worker rows say `(missing)` while
+  those provider calls work — the routes are labelled separately for that
+  reason.
 
 For `triss_ask` and `triss_review`, `provider: "glm"` requires
 `ZHIPU_API_KEY` rather than `TRISS_WORKER_API_KEY`. `pro` selects `glm-5.2` on
@@ -232,6 +236,16 @@ a preset, so `zai/flash` is valid. When neither the request nor
 whichever one works for the rest of the process (re-probed if the key
 changes). A pinned endpoint is never second-guessed.
 
+For `provider: "kimi"`, `MOONSHOT_API_KEY` is required instead. `pro` selects
+`kimi-k3` (the flagship) and `flash` selects `kimi-k2.6` (the cheapest
+current-generation model). There is a single OpenAI-compatible endpoint
+(`https://api.moonshot.ai/v1`; override with `TRISS_KIMI_BASE_URL`, e.g. for
+the China-mainland `api.moonshot.cn`), so model ids are passed bare — no
+prefix grammar and no endpoint auto-correction to reason about. The Kimi for
+Coding subscription is not usable here: its endpoint speaks the Anthropic
+protocol, which these tools' OpenAI client cannot speak — it works through
+`triss_coder_run` instead.
+
 Exposed **only when ATLASSIAN_BASE_URL/EMAIL/API_TOKEN are all set**
 (both Jira and Confluence reuse the same Atlassian credentials):
 
@@ -298,9 +312,11 @@ override for self-hosted instances):
   `triss_gitlab_update` `triss_gitlab_comment`
 
 Exposed **when a provider credential is set** — `ZHIPU_API_KEY` (Z.AI GLM,
-the default) **or** `OPENCODE_API_KEY` (OpenCode Zen — see
-[opencode-zen.md](opencode-zen.md)). Setup: `triss coder init`
-(`--provider opencode-zen` for Zen) or `triss config wizard coder`.
+the default), `OPENCODE_API_KEY` (OpenCode Zen — see
+[opencode-zen.md](opencode-zen.md)), `MOONSHOT_API_KEY` (Moonshot Kimi
+pay-as-you-go), **or** `KIMI_API_KEY` (Kimi for Coding subscription).
+Setup: `triss coder init` (`--provider opencode-zen`, `--provider moonshot`,
+or `--provider kimi-for-coding`) or `triss config wizard coder`.
 
 - `triss_coder_run` — delegate an implementation task to a coding
   agent (default `opencode` engine; `engine: "crush"` selects the crush
@@ -315,13 +331,16 @@ the default) **or** `OPENCODE_API_KEY` (OpenCode Zen — see
   isolate-OFF, crush resolves unset to isolate-ON (crush 0.1.3's
   `permissions.run` config is inert and denied bash deadlocks, so the
   worktree is its reliable safety layer). `model` takes a `<provider>/<id>`
-  string — a Z.AI GLM (`zai-coding-plan/glm-5.2`) or an OpenCode Zen model
-  (`opencode/hy3-free`, which needs `OPENCODE_API_KEY`); triss forwards only
-  the key that model's provider requires.
+  string — a Z.AI GLM (`zai-coding-plan/glm-5.2`), an OpenCode Zen model
+  (`opencode/hy3-free`, needs `OPENCODE_API_KEY`), a Moonshot Kimi model
+  (`moonshotai/kimi-k2.7-code`, needs `MOONSHOT_API_KEY`), or a Kimi for
+  Coding model (`kimi-for-coding/k3`, needs `KIMI_API_KEY`); triss forwards
+  only the key that model's provider requires.
 - `triss_coder_status` — the default engine, each engine's version/install
   state (`opencode` vs the pinned version, `crush` presence), which
-  `opencode.json` / `crush.json` files exist, `ZHIPU_API_KEY` /
-  `OPENCODE_API_KEY` presence (never the value), and how many isolation
+  `opencode.json` / `crush.json` files exist, provider key presence
+  (`ZHIPU_API_KEY` / `OPENCODE_API_KEY` / `MOONSHOT_API_KEY` /
+  `KIMI_API_KEY` — never the value), and how many isolation
   worktrees are live.
 
 **Timeout defaults to 1500s (25 min) over MCP**, above the CLI's 900s,
@@ -399,7 +418,8 @@ fresh `triss mcp install` requires a session restart to take effect.
 **"Triss listed but a model call fails"** — `triss status` to check the
 provider's API key. Core tools are always listed: their default `worker`
 route needs `TRISS_WORKER_API_KEY`, while `triss_ask` and `triss_review` with
-`provider: "glm"` need `ZHIPU_API_KEY`.
+`provider: "glm"` need `ZHIPU_API_KEY` and with `provider: "kimi"` need
+`MOONSHOT_API_KEY`.
 
 **"Jira tools missing in this project"** — Triss couldn't find the
 ATLASSIAN_* triple. Either your global `~/.config/triss/.env` has them
@@ -443,12 +463,15 @@ invocation.
 
 GLM records keep the endpoint the call actually used (`zai-coding-plan/` or
 `zai/`) — including after an endpoint auto-correction, so a retried call is
-billed to the endpoint that served it. Subscription calls retain the known
-`$0` accounting (the plan meters by quota), and PAYG calls carry Z.AI's
-published list prices for the catalogue models. Anything still unpriced —
-a GLM id outside that catalogue, `opencode/*` OpenCode Zen — keeps numeric
-`cost_usd: 0` for JSONL compatibility, adds `cost_usd_known: false`, and is
-displayed by `triss usage` as `unknown`, not as free. Set the matching
+billed to the endpoint that served it. Subscription calls (Z.AI Coding Plan,
+`kimi-for-coding/*`) retain the known `$0` accounting (the plan meters by
+quota), and PAYG calls carry the providers' published list prices for the
+catalogue models — Kimi ids are priced whether logged bare (`kimi-k3`, from
+ask/review) or with opencode's prefix (`moonshotai/kimi-k3`, from coder
+runs). Anything still unpriced — a GLM id outside that catalogue,
+`opencode/*` OpenCode Zen — keeps numeric `cost_usd: 0` for JSONL
+compatibility, adds `cost_usd_known: false`, and is displayed by
+`triss usage` as `unknown`, not as free. Set the matching
 `TRISS_PRICE_<MODEL_ID>` override to account for one.
 
 To attribute all calls from one MCP server process to a single outer