triss-coworker 0.24.2 → 0.26.0

package/CHANGELOG.md

@@ -7,6 +7,119 @@ 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
+
+- `triss ask` and `triss review` now accept `--provider glm` (also available
+  as the `provider` field on `triss_ask` / `triss_review` MCP tools). They reuse
+  `ZHIPU_API_KEY` for direct OpenAI-compatible chat completions, while the
+  existing `worker` provider remains the default and `deepseek` is an alias.
+  `--model pro` maps to `glm-5.2`, and `--model flash` — Triss's cheap
+  bulk-read tier — maps to `glm-4.7` on the subscription endpoint and
+  `glm-4.5-air` on pay-as-you-go. Explicit `zai-coding-plan/<model>` /
+  `zai/<model>` prefixes select the endpoint, and may carry a preset
+  (`zai/flash`). Usage records retain that endpoint identity: subscription
+  calls remain known `$0` because the plan meters by quota, while PAYG calls
+  are priced from Z.AI's published rates.
+- `triss status` and the `triss_status` MCP tool print a GLM routing block:
+  whether `ZHIPU_API_KEY` is set, the endpoint a `--provider glm` call resolves
+  to, what selected it, and that endpoint's preset models. Worker credential
+  rows are now labelled as such, so a GLM-only setup no longer reads as
+  unconfigured just because it has no worker key.
+- Pay-as-you-go GLM models now ship with Z.AI's published list prices, so
+  `triss usage` reports a real cost for them instead of `unknown`.
+  Provider selection is intentionally scoped to `ask` and `review`;
+  `chat`, `fetch`, `write`, and `commit-msg` keep their existing worker route,
+  while `triss coder` remains the separate agentic path.
+
+### Changed
+
+- Usage JSONL records keep `cost_usd` numeric for compatibility with existing
+  dashboards and add `cost_usd_known: false` when no model price is configured.
+  `triss usage` excludes those zeros from known totals and reports them as
+  unknown. This includes unpriced `opencode/*` OpenCode Zen models; configure
+  `TRISS_PRICE_<MODEL_ID>` to account for one. Existing log entries are not
+  rewritten: older bare GLM model ids and their previously recorded numeric
+  costs remain unchanged.
+
+### Fixed
+
+- A GLM call that nothing pinned to an endpoint is no longer a one-shot guess.
+  A Z.AI key carries no marker of which plan it belongs to, so a pay-as-you-go
+  key used to fail outright against the `zai-coding-plan` default. Such a call
+  is now retried once on the other endpoint; the working one is reported on
+  stderr and reused for the rest of the process, and re-probed if the key
+  changes. The cache stores only the working endpoint, never the API key or a
+  fingerprint derived from it. Endpoints pinned by an explicit prefix or
+  `TRISS_CODER_MODEL` are never second-guessed, and a key that works on neither
+  endpoint still surfaces the original rejection.
+- A preset behind a provider prefix is resolved instead of being sent
+  verbatim: `zai/flash` previously reached the provider as the literal model
+  id `flash`.
+- Long-lived MCP processes now refresh file-backed `TRISS_CODER_MODEL` and
+  `ZHIPU_API_KEY` values between calls, including edits and removals, while
+  preserving the precedence of values supplied by the parent environment.
+- Every model routed through the `zai-coding-plan/` subscription endpoint is
+  treated as known plan-metered usage instead of requiring a hardcoded model
+  allowlist. Explicit `TRISS_PRICE_<MODEL>` overrides still take precedence.
+- A GLM `HTTP 429` now carries the resolved-endpoint hint instead of surfacing
+  Z.AI's bare "Insufficient balance or no resource package" text. That reply is
+  what a subscription key gets on the pay-as-you-go endpoint, so the message now
+  names both the balance and the wrong-plan cause.
+
 ## [0.24.2] — 2026-07-15
 
 ### Changed
@@ -667,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 |
@@ -288,6 +290,14 @@ triss ask --paths src/auth.ts src/db.ts \
 triss ask --paths "src/**/*.ts" \
           --question "Find SQL injection risks" \
           --model pro --max-tokens 16384
+
+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.
@@ -335,7 +345,7 @@ triss usage --json                   # raw log records
 triss usage --reset                  # clear the log
 ```
 
-Every worker call (CLI **and** MCP) appends one record to
+Every model call (CLI **and** MCP) appends one record to
 `~/.cache/triss/usage.jsonl` with model, tokens, cached tokens, computed
 USD cost, working directory, a label like `triss/ask`, and a per-invocation
 `call_id` (UUIDv4). An optional `parent_call_id` lets a host group several
@@ -343,9 +353,17 @@ Triss calls under a single outer session — set `TRISS_PARENT_CALL_ID` in
 the environment that launches Triss (e.g. in your MCP server's `env`
 block) and every record from that process carries it. External dashboards
 (e.g. tokentelemetry) can group by either field. List-price defaults for
-DeepSeek are baked in; override per-model with
-`TRISS_PRICE_<MODEL_ID>=miss,hit,out` (USD per token). Disable tracking
-entirely with `TRISS_USAGE_LOG=0`.
+DeepSeek are baked in. GLM records retain `zai-coding-plan/` or `zai/` so
+subscription usage stays known `$0` while unpriced PAYG usage is shown as
+`unknown`, never as free. Any other unpriced model, including `opencode/*`
+OpenCode Zen, is also `unknown` unless configured with a matching
+`TRISS_PRICE_<MODEL_ID>` override. The JSONL keeps `cost_usd` numeric for
+dashboard compatibility and marks unpriced records with `cost_usd_known: false`.
+Existing records are not migrated, so older bare GLM model ids remain as
+originally logged. Override per-model with
+`TRISS_PRICE_<MODEL_ID>=miss,hit,out` (USD per token), for example
+`TRISS_PRICE_ZAI_GLM_5_2=...`. Disable tracking entirely with
+`TRISS_USAGE_LOG=0`.
 
 ### Streaming output
 
@@ -391,6 +409,8 @@ triss review                 # current branch vs auto-detected base
 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
@@ -430,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
@@ -443,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
@@ -481,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
@@ -496,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
@@ -582,6 +625,47 @@ 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 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
+bulk-read tier — maps to `glm-4.7` on the subscription endpoint and to
+`glm-4.5-air` ($0.20/$1.10 per 1M) on pay-as-you-go. The subscription endpoint
+serves a `glm-4.5-air` request as `glm-4.7`, so the preset names what actually
+runs there.
+
+`ZHIPU_API_KEY` is reused. Prefix an explicit model with `zai-coding-plan/`
+or `zai/` to select the subscription or pay-as-you-go endpoint; otherwise
+Triss inherits the prefix from `TRISS_CODER_MODEL` and falls back to the
+coding-plan endpoint. A Z.AI key does not say which plan it belongs to, so
+when nothing pinned the endpoint and the call comes back `401`/`403`/`429`,
+Triss retries once on the other endpoint, prints which one worked, and reuses
+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.
+
 ### Provider recipes
 
 #### DeepSeek (default, recommended)
@@ -590,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,16 +66,19 @@ program
 
 program
   .command('ask')
-  .description('Delegate bulk reading (files, URLs, and/or piped stdin) to DeepSeek; 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), 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')
   .option('--no-stream', "disable streaming output (default streams when stdout is a TTY)")
-  .action(wrap(runAsk));
+  // Commander also supplies its Command instance to action handlers. Adapt
+  // at the CLI boundary so runAsk receives only its documented options.
+  .action((opts) => wrap(runAsk)(opts));
 
 program
   .command('write')
@@ -128,10 +131,11 @@ program
 
 program
   .command('review [pr]')
-  .description('Code review via DeepSeek. 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), 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')
@@ -231,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.
@@ -218,12 +218,21 @@ env:
 
 You added `.triss.env` to a project after Claude Code was already
 running there. As of v0.9.3, **no restart needed** — `.env` files are
-re-read on every `tools/list` request, so the next time the agent or
-`claude /mcp` lists tools, the new ones appear (or disappear).
+re-read on every `tools/list` request, so newly added integration
+credentials can expose their tools on the next listing. Replacing or removing
+an integration credential that is already loaded still requires restarting
+that MCP process.
 
 The only thing that requires a restart is the *initial* MCP-server
 registration — i.e. running `triss mcp install` for the first time.
-After that, credential changes are live.
+After that, newly added credentials are discovered live.
+
+Separately, GLM calls (`triss_ask` / `triss_review` with `provider: "glm"`)
+re-read file-backed `TRISS_CODER_MODEL` and `ZHIPU_API_KEY` on each call.
+Editing or removing either value in `.triss.env` takes effect on the next GLM
+call without restarting the MCP server. Values supplied by the parent process
+environment still take precedence. This is a GLM per-call guarantee; it does
+not extend the tool-catalogue reload behaviour above to every integration.
 
 ## Environment reference
 
@@ -241,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`|
 
-### Coder (GLM coding agent)
+### GLM, Kimi, and coder
 
 | Variable                        | Required | Default            | Notes                                     |
 | -------------------------------- | -------- | ------------------ | ------------------------------------------ |
-| `ZHIPU_API_KEY`                  | yes¹     | —                  | Z.AI API key for GLM models — <https://z.ai/manage-apikey/apikey-list> |
+| `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) |
@@ -265,19 +277,59 @@ file) when the existing `model` prefix doesn't match what the key
 verified against — that mismatch is what makes opencode retry a model
 call it can never complete.
 
+`triss ask` and `triss review` can use the same key without spawning a coding
+agent: pass `--provider glm`. `pro` maps to `glm-5.2` on both endpoints;
+`flash` maps to `glm-4.7` on `zai-coding-plan` and `glm-4.5-air` on `zai`,
+because the subscription endpoint answers a `glm-4.5-air` request with
+`glm-4.7` and a preset should name the model that actually runs. A
+provider-prefixed model selects the endpoint explicitly
+(`zai-coding-plan/glm-5.2` for a subscription key, `zai/glm-5.2` for
+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
+call is rejected with `401`, `403`, or `429` (Z.AI answers a plan mismatch
+with "Insufficient balance or no resource package"), Triss retries the request
+once on the other endpoint. If that works, it warns on stderr and reuses that
+endpoint for the rest of the process; the discovery is dropped when the key
+changes. An explicitly prefixed or `TRISS_CODER_MODEL`-pinned endpoint is
+never second-guessed. Pin one to skip the probe entirely — and note that a
+pinned endpoint also selects that endpoint's presets. `triss status` and the
+`triss_status` MCP tool print the resolved endpoint, its source, and the
+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
@@ -337,7 +389,7 @@ are unaffected.
 | `TRISS_USAGE_LOG`              | (on)        | `0` disables the usage tracker (`~/.cache/triss/usage.jsonl`) |
 | `TRISS_USAGE_LOG_CWD`          | (on)        | `0` omits the absolute cwd from each record (then `--by-project` groups under `(unknown)`) |
 | `TRISS_USAGE_LOG_MAX_BYTES`    | `10485760`  | Rotate the active log to `usage.jsonl.old` once it crosses this size (10 MB default) |
-| `TRISS_PRICE_<MODEL_ID>`       | list prices | `miss,hit,out` USD-per-token override per model (e.g. for promo or non-DeepSeek providers) |
+| `TRISS_PRICE_<MODEL_ID>`       | list prices | `miss,hit,out` USD-per-token override per model (e.g. `TRISS_PRICE_ZAI_GLM_5_2` for `zai/glm-5.2`); models without a price, including `opencode/*` Zen models, report `unknown`, not `$0` |
 | `TRISS_FETCH_MAX_BYTES`        | `10485760`  | Max body size for `triss fetch` (default 10 MB)           |
 | `TRISS_RESTRICT_PATHS`         | `1` in MCP, unset in CLI | `0` opts the MCP server out of the project-root file IO sandbox |
 | `TRISS_ALLOW_PRIVATE_NETWORKS` | (off)       | `1` allows `triss fetch` / `triss ask --urls` to hit RFC1918, loopback, link-local, and cloud-metadata IPs. Off blocks SSRF; turn on only for self-hosted internal docs. **Known residual risk:** the guard checks DNS once before fetch; the underlying connection performs another lookup, leaving a narrow DNS-rebinding window. For high-trust environments use network-level egress filtering as the primary control. |
@@ -367,7 +419,24 @@ baked-in DeepSeek list prices (e.g. you point Triss at a different
 provider, or want the discounted rate), set
 `TRISS_PRICE_<MODEL>=<input_cache_miss>,<input_cache_hit>,<output>` in
 USD per token. Example: `TRISS_PRICE_DEEPSEEK_V4_PRO=4.35e-7,3.625e-9,8.7e-7`
-applies the 75% promotional pricing to the pro preset.
+applies the 75% promotional pricing to the pro preset. PAYG GLM calls use the
+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`. 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
+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.
 
 **Claude Code integration step in the wizard** — split by mode:
 

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`. |