playmaker-cli 0.10.0__tar.gz → 0.11.0__tar.gz

{playmaker_cli-0.10.0 → playmaker_cli-0.11.0}/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.0] - 2026-09-04
+
+### Added
+
+- **`kimi` lane — the Kimi Code CLI as a first-class agent.**
+  `playmaker dispatch kimi -m kimi-code/k3-256k` runs `kimi -p …
+  --output-format stream-json`, tracks the session, resumes with `-S`, and
+  reads the per-cwd `wire.jsonl` for `summary`. K3 is a senior-tier model on a
+  subscription nobody else on the machine draws from, and routing it through
+  opencode would have needed a second credential; the native CLI reuses its
+  own OAuth login.
+
 ## [0.10.0] - 2026-09-04
 
 ### Added

{playmaker_cli-0.10.0 → playmaker_cli-0.11.0}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.5
 Name: playmaker-cli
-Version: 0.10.0
-Summary: Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity and opencode sub-agents in parallel.
+Version: 0.11.0
+Summary: Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity, Kimi Code and opencode sub-agents in parallel.
 Project-URL: Homepage, https://github.com/vladsafedev/playmaker
 Project-URL: Repository, https://github.com/vladsafedev/playmaker
 Project-URL: Issues, https://github.com/vladsafedev/playmaker/issues
 Author-email: Vladislav Shulyugin <vladislav.shulyugin@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
-Keywords: agents,ai,antigravity,claude,claude-code,cli,codex,gemini,glm,opencode,orchestration,subagents
+Keywords: agents,ai,antigravity,claude,claude-code,cli,codex,gemini,glm,kimi,kimi-code,opencode,orchestration,subagents
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -32,7 +32,7 @@ Description-Content-Type: text/markdown
 [![Python](https://img.shields.io/pypi/pyversions/playmaker-cli.svg?cacheSeconds=3600)](https://pypi.org/project/playmaker-cli/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-**Run Claude Code, Codex, Antigravity and opencode as parallel sub-agents from one terminal — and spend separate quotas instead of one.**
+**Run Claude Code, Codex, Antigravity, Kimi Code and opencode as parallel sub-agents from one terminal — and spend separate quotas instead of one.**
 
 You stay in your Claude Code session doing the part only you can do. `playmaker`
 fans the rest out to other agent CLIs as detached processes, tracks them,
@@ -74,10 +74,11 @@ in one serial session:
 1. **Wall-clock speed.** A task that decomposes into 3–5 independent
    work-streams (schema, backend, frontend, tests, docs) finishes 2–4× faster
    when each stream runs as its own parallel agent.
-2. **Provider arbitrage.** Codex, Antigravity and opencode quotas are entirely
-   separate pools from your Anthropic plan. Every slice you hand them is
-   capacity your main session never spends — and Antigravity's roster includes
-   Claude Sonnet/Opus, so even Claude-quality work can run on Google's pool.
+2. **Provider arbitrage.** Codex, Antigravity, Kimi Code and opencode quotas
+   are entirely separate pools from your Anthropic plan. Every slice you hand
+   them is capacity your main session never spends — and Antigravity's roster
+   includes Claude Sonnet/Opus, so even Claude-quality work can run on Google's
+   pool. Kimi Code brings its own subscription with the senior-tier K3.
    `opencode` widens this the most: one CLI fronting ~75 providers, from a z.ai
    GLM coding plan to models running locally on your own machine.
 3. **Bucket arbitrage inside one plan.** Headless `claude -p` draws on the same
@@ -146,6 +147,10 @@ The other agents differ, because their CLIs do:
   { "permission": { "edit": "allow", "bash": "allow", "webfetch": "deny" } }
   ```
 
+- **kimi** has no permission flags at all in headless mode — `kimi -p` refuses
+  `--auto`, `--yolo` and `--plan`, and already runs with auto-approval, so
+  there is no read-only mode below the prompt.
+
 - **gemini** (legacy) runs with `--yolo`.
 
 ## Install
@@ -183,6 +188,7 @@ playmaker agents          # which agent CLIs are reachable
 | **Codex CLI** | `npm i -g @openai/codex` | the model roster depends on your plan; omit `--model` to use the account default |
 | **Antigravity (`agy`)** | bundled with [Antigravity](https://antigravity.google) | `--model claude-opus-4-6-thinking` — the roster moves, so read it from `agy models` |
 | **opencode** | `brew install sst/tap/opencode` (or see [opencode.ai](https://opencode.ai)) | `--model provider/model`, e.g. `zai-coding-plan/glm-5.2`; roster from `opencode models`, providers from `opencode auth login` |
+| **Kimi Code CLI** | `npm i -g @moonshot-ai/kimi-code` | needs Node ≥ 22.19 (a wrapper that pins a newer Node is fine — point `[agents.kimi] binary` at it); `--model kimi-code/k3-256k` — 256k window at half the quota cost of `k3`; log in once with `kimi login --region global`; model ids from `~/.kimi-code/config.toml` |
 | **Gemini CLI** (legacy) | `npm i -g @google/gemini-cli` | still supported, superseded by `agy` |
 
 At least one is required; `playmaker agents` tells you which it can see.
@@ -317,6 +323,7 @@ and locates the session file the tool writes locally. Empirically:
 | Codex | `~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ts>-<thread_id>.jsonl` |
 | Antigravity | `~/.gemini/antigravity-cli/brain/<conversation-id>/.system_generated/logs/transcript_full.jsonl` |
 | opencode | SQLite — `~/.local/share/opencode/opencode.db` (`session` / `message` / `part`); playmaker keeps a pointer at `~/.playmaker/opencode/<id>.session` |
+| kimi | `~/.kimi-code/sessions/wd_<cwd-basename>_<hash>/session_<id>/agents/main/wire.jsonl` (per-cwd; `KIMI_CODE_HOME` overrides the root) |
 | Gemini | `~/.gemini/tmp/<cwd-basename>/chats/session-<ts>-<short_id>.{json,jsonl}` |
 
 `thread` and `summary` normalize all of them into the same turn list, so every

{playmaker_cli-0.10.0 → playmaker_cli-0.11.0}/README.md

@@ -5,7 +5,7 @@
 [![Python](https://img.shields.io/pypi/pyversions/playmaker-cli.svg?cacheSeconds=3600)](https://pypi.org/project/playmaker-cli/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-**Run Claude Code, Codex, Antigravity and opencode as parallel sub-agents from one terminal — and spend separate quotas instead of one.**
+**Run Claude Code, Codex, Antigravity, Kimi Code and opencode as parallel sub-agents from one terminal — and spend separate quotas instead of one.**
 
 You stay in your Claude Code session doing the part only you can do. `playmaker`
 fans the rest out to other agent CLIs as detached processes, tracks them,
@@ -47,10 +47,11 @@ in one serial session:
 1. **Wall-clock speed.** A task that decomposes into 3–5 independent
    work-streams (schema, backend, frontend, tests, docs) finishes 2–4× faster
    when each stream runs as its own parallel agent.
-2. **Provider arbitrage.** Codex, Antigravity and opencode quotas are entirely
-   separate pools from your Anthropic plan. Every slice you hand them is
-   capacity your main session never spends — and Antigravity's roster includes
-   Claude Sonnet/Opus, so even Claude-quality work can run on Google's pool.
+2. **Provider arbitrage.** Codex, Antigravity, Kimi Code and opencode quotas
+   are entirely separate pools from your Anthropic plan. Every slice you hand
+   them is capacity your main session never spends — and Antigravity's roster
+   includes Claude Sonnet/Opus, so even Claude-quality work can run on Google's
+   pool. Kimi Code brings its own subscription with the senior-tier K3.
    `opencode` widens this the most: one CLI fronting ~75 providers, from a z.ai
    GLM coding plan to models running locally on your own machine.
 3. **Bucket arbitrage inside one plan.** Headless `claude -p` draws on the same
@@ -119,6 +120,10 @@ The other agents differ, because their CLIs do:
   { "permission": { "edit": "allow", "bash": "allow", "webfetch": "deny" } }
   ```
 
+- **kimi** has no permission flags at all in headless mode — `kimi -p` refuses
+  `--auto`, `--yolo` and `--plan`, and already runs with auto-approval, so
+  there is no read-only mode below the prompt.
+
 - **gemini** (legacy) runs with `--yolo`.
 
 ## Install
@@ -156,6 +161,7 @@ playmaker agents          # which agent CLIs are reachable
 | **Codex CLI** | `npm i -g @openai/codex` | the model roster depends on your plan; omit `--model` to use the account default |
 | **Antigravity (`agy`)** | bundled with [Antigravity](https://antigravity.google) | `--model claude-opus-4-6-thinking` — the roster moves, so read it from `agy models` |
 | **opencode** | `brew install sst/tap/opencode` (or see [opencode.ai](https://opencode.ai)) | `--model provider/model`, e.g. `zai-coding-plan/glm-5.2`; roster from `opencode models`, providers from `opencode auth login` |
+| **Kimi Code CLI** | `npm i -g @moonshot-ai/kimi-code` | needs Node ≥ 22.19 (a wrapper that pins a newer Node is fine — point `[agents.kimi] binary` at it); `--model kimi-code/k3-256k` — 256k window at half the quota cost of `k3`; log in once with `kimi login --region global`; model ids from `~/.kimi-code/config.toml` |
 | **Gemini CLI** (legacy) | `npm i -g @google/gemini-cli` | still supported, superseded by `agy` |
 
 At least one is required; `playmaker agents` tells you which it can see.
@@ -290,6 +296,7 @@ and locates the session file the tool writes locally. Empirically:
 | Codex | `~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ts>-<thread_id>.jsonl` |
 | Antigravity | `~/.gemini/antigravity-cli/brain/<conversation-id>/.system_generated/logs/transcript_full.jsonl` |
 | opencode | SQLite — `~/.local/share/opencode/opencode.db` (`session` / `message` / `part`); playmaker keeps a pointer at `~/.playmaker/opencode/<id>.session` |
+| kimi | `~/.kimi-code/sessions/wd_<cwd-basename>_<hash>/session_<id>/agents/main/wire.jsonl` (per-cwd; `KIMI_CODE_HOME` overrides the root) |
 | Gemini | `~/.gemini/tmp/<cwd-basename>/chats/session-<ts>-<short_id>.{json,jsonl}` |
 
 `thread` and `summary` normalize all of them into the same turn list, so every

{playmaker_cli-0.10.0 → playmaker_cli-0.11.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "playmaker-cli"
-version = "0.10.0"
-description = "Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity and opencode sub-agents in parallel."
+version = "0.11.0"
+description = "Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity, Kimi Code and opencode sub-agents in parallel."
 readme = "README.md"
 requires-python = ">=3.11"
 license = "MIT"
@@ -19,6 +19,8 @@ keywords = [
     "codex",
     "antigravity",
     "gemini",
+    "kimi",
+    "kimi-code",
     "opencode",
     "glm",
     "subagents",

{playmaker_cli-0.10.0 → playmaker_cli-0.11.0}/skills/playmaker-coach/references/agent-gotchas.md

@@ -65,6 +65,22 @@ line from `agy models` / `opencode models` rather than typing it.
 - Neither trap applies to **review** dispatches, which write nothing — which makes opencode a
   perfectly good reviewer even where it is a shaky implementer.
 
+## kimi (Kimi Code CLI)
+
+- There is **no read-only mode below the prompt**: `-p` refuses `--auto`, `--yolo` and `--plan`
+  (exit 1) and already runs with auto-approval. Only dispatch work you would run unattended anyway.
+- The session id arrives **only in the trailing `session.resume_hint` line**, so `playmaker list`
+  shows the agent session late — do not conclude a dispatch failed just because the id has not
+  appeared yet.
+- Sessions are **per-cwd**: `kimi session list` from another directory shows nothing. Track the
+  session through playmaker, not through the CLI.
+- The stream carries **no token/cost fields** — there is nothing to budget against mid-run.
+- Exit codes: **exit 1 is non-retryable** (auth, quota, unknown model — "is not configured in
+  config.toml"); **exit 75 is retryable**. Fix the cause on 1, re-dispatch on 75.
+- K3 is **slow on real tickets** — never `--sync` a big WP; dispatch detached and poll.
+- Needs **Node ≥ 22.19** — hence the wrapper binary; point `[agents.kimi] binary` at it.
+- **Always pass `-m kimi-code/k3-256k`** — the CLI default is the weaker K2.7 `kimi-for-coding`.
+
 ## Worktrees
 
 Parallel WPs that touch the same files collide. Give each its own git worktree and dispatch with

{playmaker_cli-0.10.0 → playmaker_cli-0.11.0}/skills/playmaker-coach/references/lanes.md

@@ -18,8 +18,9 @@ pays. Four lanes:
    (`haiku` for trivial mechanical work). playmaker runs it in `acceptEdits`: it writes freely
    inside `--cwd` and is refused outside it, so keep every path in the prompt inside `--cwd`.
 
-4. **External dispatch — `codex` / `agy` / `opencode`.** Each on its own subscription or plan — the
-   home for write-heavy parallel implementation that can leave the Anthropic subscription.
+4. **External dispatch — `codex` / `agy` / `opencode` / `kimi`.** Each on its own subscription or
+   plan — the home for write-heavy parallel implementation that can leave the Anthropic
+   subscription.
    - **`agy` (Antigravity)** carries more than Google models: alongside Gemini Flash and Pro tiers it
      serves **Claude Sonnet/Opus (Thinking)** and a GPT-OSS tier. Its Claude runs on *Google's*
      pool and spends none of the Anthropic bucket — but that roster has trailed Anthropic's own
@@ -29,6 +30,8 @@ pays. Four lanes:
    - **`opencode`** is the widest lane: one CLI over ~75 providers addressed as `provider/model` — a
      GLM coding plan, or a model running locally on this machine, which spends no subscription quota
      at all.
+   - **`kimi`** runs the Kimi Code CLI on its own subscription: senior tier (K3), native login, no
+     opencode.
 
 **Never write an agy or opencode model name from memory** — run `agy models` / `opencode models` and
 copy a line. Both rosters and their spelling move with releases, and playmaker validates `--model`

playmaker_cli-0.11.0/src/playmaker/agents/kimi.py

@@ -0,0 +1,459 @@
+"""Kimi Code CLI handler.
+
+Empirically (kimi-code 0.41.0):
+- oneshot: `kimi -m <model> -p "<prompt>" --output-format stream-json`; resume
+  uses `kimi -S <session_id> -p ...` in the same working directory
+- prompt mode auto-approves tool calls already; it refuses `--auto`, `--yolo`,
+  and `--plan`, and it has no read-only flag
+- stream-json is JSONL. The final assistant text is in `role: assistant`
+  `content`; the session id arrives only in a trailing
+  `meta/session.resume_hint` event
+- exit 1 is non-retryable (auth, quota, or an unknown model); exit 75 is
+  retryable (rate limit or 5xx). This handler does not retry; callers may
+  re-dispatch after an exit-75 failure
+- sessions live under `$KIMI_CODE_HOME` (or `~/.kimi-code`):
+  `sessions/wd_*/session_<uuid>/agents/main/wire.jsonl`, with `state.json`
+  alongside the `agents/` directory
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import threading
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from playmaker.agents.base import DispatchResult, SessionStartedCallback, Turn
+from playmaker.config import agent_binary, agent_setting
+
+
+def kimi_code_home() -> Path:
+    """Kimi's session root, respecting its documented environment override."""
+    configured = os.environ.get("KIMI_CODE_HOME")
+    return Path(configured).expanduser() if configured else Path("~/.kimi-code").expanduser()
+
+
+class KimiHandler:
+    name = "kimi"
+
+    def is_available(self) -> bool:
+        return shutil.which(agent_binary("kimi")) is not None
+
+    def dispatch(
+        self,
+        prompt: str,
+        cwd: Path,
+        files: list[Path] | None = None,
+        on_session_started: SessionStartedCallback | None = None,
+        model: str | None = None,
+    ) -> DispatchResult:
+        return self._run(
+            prompt,
+            cwd,
+            files or [],
+            on_session_started=on_session_started,
+            model=model,
+            session_id=None,
+        )
+
+    def resume(
+        self,
+        prompt: str,
+        cwd: Path,
+        agent_session_id: str,
+        files: list[Path] | None = None,
+        on_session_started: SessionStartedCallback | None = None,
+        model: str | None = None,
+    ) -> DispatchResult:
+        return self._run(
+            prompt,
+            cwd,
+            files or [],
+            on_session_started=on_session_started,
+            model=model,
+            session_id=agent_session_id,
+        )
+
+    def _run(
+        self,
+        prompt: str,
+        cwd: Path,
+        files: list[Path],
+        *,
+        on_session_started: SessionStartedCallback | None,
+        model: str | None,
+        session_id: str | None,
+    ) -> DispatchResult:
+        effective_model = model or agent_setting("kimi", "model")
+        cmd = [agent_binary("kimi")]
+        if session_id:
+            cmd += ["-S", session_id]
+        if effective_model:
+            cmd += ["-m", str(effective_model)]
+        cmd += ["-p", self._build_prompt(prompt, files), "--output-format", "stream-json"]
+
+        t0 = time.monotonic()
+        proc = subprocess.Popen(
+            cmd,
+            cwd=str(cwd),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+        )
+
+        agent_session_id: str | None = None
+        assistant_contents: list[str] = []
+        first_lines: list[str] = []
+        stderr_parts: list[str] = []
+        stderr = proc.stderr
+
+        def drain_stderr() -> None:
+            if stderr is not None:
+                stderr_parts.append(stderr.read())
+
+        stderr_thread = threading.Thread(target=drain_stderr, daemon=True)
+        stderr_thread.start()
+
+        def remember_session_id(candidate: object) -> None:
+            nonlocal agent_session_id
+            if agent_session_id is not None or not isinstance(candidate, str) or not candidate:
+                return
+            agent_session_id = candidate
+            if on_session_started is not None:
+                try:
+                    on_session_started(candidate)
+                except Exception:
+                    pass
+
+        assert proc.stdout is not None
+        for raw in proc.stdout:
+            if len(first_lines) < 3:
+                first_lines.append(raw)
+            line = raw.strip()
+            if not line:
+                continue
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(event, dict):
+                continue
+
+            if event.get("role") == "assistant":
+                content = event.get("content")
+                if isinstance(content, str) and content:
+                    assistant_contents.append(content)
+            elif event.get("role") == "meta" and event.get("type") == "session.resume_hint":
+                remember_session_id(event.get("session_id"))
+
+        proc.wait()
+        stderr_thread.join()
+        stderr_text = "".join(stderr_parts)
+        duration = time.monotonic() - t0
+
+        if proc.returncode != 0:
+            detail = stderr_text.strip() or "".join(first_lines)[:500] or "(no error output)"
+            raise RuntimeError(f"kimi failed (exit {proc.returncode}): {detail}")
+
+        if agent_session_id is None:
+            remember_session_id(self._latest_session_id(cwd))
+        if agent_session_id is None:
+            raise RuntimeError(
+                "kimi stream-json missing session.resume_hint; first lines:\n"
+                f"{''.join(first_lines)[:500]}"
+            )
+
+        session_file = self.find_session_file(agent_session_id, cwd)
+        initial_output = next(
+            (content for content in reversed(assistant_contents) if content.strip()), ""
+        ) or self._last_assistant_text(session_file)
+        return DispatchResult(
+            agent_session_id=agent_session_id,
+            cwd=str(cwd),
+            session_file=session_file,
+            initial_output=initial_output,
+            cost_usd=None,
+            duration_seconds=duration,
+            exit_code=proc.returncode,
+        )
+
+    def _latest_session_id(self, cwd: Path) -> str | None:
+        """Ask Kimi's per-working-directory index for its most recent session."""
+        try:
+            proc = subprocess.run(
+                [agent_binary("kimi"), "session", "list", "--json"],
+                cwd=str(cwd),
+                capture_output=True,
+                text=True,
+            )
+        except (OSError, subprocess.SubprocessError):
+            return None
+        if proc.returncode != 0:
+            return None
+
+        entries = self._session_list_entries(proc.stdout)
+        # `kimi session list --help` says entries are most recently updated
+        # first. Sort timestamped listings too, so an unordered response does
+        # not bind a dispatch to an older session.
+        entries.sort(key=self._session_entry_timestamp, reverse=True)
+        expected_cwd = self._resolved_cwd(cwd)
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            listed_cwd = entry.get("cwd") or entry.get("workDir")
+            if isinstance(listed_cwd, str) and self._resolved_cwd(Path(listed_cwd)) != expected_cwd:
+                continue
+            for key in ("id", "session_id", "sessionId"):
+                candidate = entry.get(key)
+                if isinstance(candidate, str) and candidate:
+                    return candidate
+        return None
+
+    @staticmethod
+    def _session_entry_timestamp(entry: object) -> tuple[int, float]:
+        if not isinstance(entry, dict):
+            return (0, 0)
+        for key in ("updatedAt", "lastUsedAt", "updated_at", "last_used_at"):
+            raw = entry.get(key)
+            if isinstance(raw, (int, float)):
+                return (1, float(raw))
+            if isinstance(raw, str):
+                try:
+                    return (1, float(raw))
+                except ValueError:
+                    try:
+                        return (1, datetime.fromisoformat(raw.replace("Z", "+00:00")).timestamp())
+                    except (OSError, OverflowError, ValueError):
+                        continue
+        return (0, 0)
+
+    @staticmethod
+    def _session_list_entries(raw: str) -> list[object]:
+        """Accept the array and object envelopes used by Kimi session listings."""
+        try:
+            decoded = json.loads(raw)
+        except json.JSONDecodeError:
+            decoded = None
+        if isinstance(decoded, list):
+            return decoded
+        if isinstance(decoded, dict):
+            for key in ("sessions", "items", "data"):
+                value = decoded.get(key)
+                if isinstance(value, list):
+                    return value
+            return [decoded]
+
+        entries: list[object] = []
+        for line in raw.splitlines():
+            try:
+                entry = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(entry, dict):
+                entries.append(entry)
+        return entries
+
+    def find_session_file(self, agent_session_id: str, cwd: Path) -> Path | None:
+        sessions_root = kimi_code_home() / "sessions"
+        if not sessions_root.is_dir():
+            return None
+        matches = list(sessions_root.glob(f"wd_*/{agent_session_id}/agents/main/wire.jsonl"))
+        matches.sort(key=self._mtime, reverse=True)
+        expected_cwd = self._resolved_cwd(cwd)
+        unverified_matches: list[Path] = []
+        saw_state_file = False
+        for path in matches:
+            state_path = path.parents[2] / "state.json"
+            if not state_path.exists():
+                unverified_matches.append(path)
+                continue
+            saw_state_file = True
+            try:
+                state = json.loads(state_path.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                continue
+            if not isinstance(state, dict) or state.get("id") != agent_session_id:
+                continue
+            state_cwd = state.get("cwd")
+            if isinstance(state_cwd, str) and self._resolved_cwd(Path(state_cwd)) == expected_cwd:
+                return path
+        if saw_state_file:
+            return None
+        workspace_prefix = f"wd_{expected_cwd.name}_"
+        for path in unverified_matches:
+            if path.parents[3].name.startswith(workspace_prefix):
+                return path
+        return None
+
+    def parse_session_file(self, path: Path) -> list[Turn]:
+        """Normalize Kimi's append-only `wire.jsonl` without runtime noise."""
+        turns: list[Turn] = []
+        assistants: dict[str, dict[str, Any]] = {}
+        call_turns: dict[str, str] = {}
+        if not path.exists():
+            return turns
+
+        def flush(turn_id: str) -> None:
+            assistant = assistants.pop(turn_id, None)
+            if assistant is None:
+                return
+            content = "\n".join(assistant["content"])
+            if content or assistant["tool_calls"] or assistant["tool_results"]:
+                turns.append(
+                    Turn(
+                        role="assistant",
+                        content=content,
+                        tool_calls=assistant["tool_calls"],
+                        tool_results=assistant["tool_results"],
+                        timestamp=assistant["timestamp"],
+                    )
+                )
+
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except OSError:
+            return turns
+        for raw in lines:
+            try:
+                event = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(event, dict):
+                continue
+            event_type = event.get("type")
+            if event_type == "turn.prompt":
+                for turn_id in list(assistants):
+                    flush(turn_id)
+                content = self._text_blocks(event.get("input"))
+                turns.append(Turn(role="user", content=content, timestamp=self._timestamp(event)))
+                continue
+            if event_type == "turn.ended":
+                turn_id = str(event.get("turnId", ""))
+                if turn_id:
+                    flush(turn_id)
+                continue
+            if event_type != "context.append_loop_event":
+                continue
+
+            loop_event = event.get("event")
+            if not isinstance(loop_event, dict):
+                continue
+            loop_type = loop_event.get("type")
+            tool_id = loop_event.get("toolCallId")
+            turn_id = str(loop_event.get("turnId", ""))
+            if loop_type == "tool.result" and not turn_id and isinstance(tool_id, str):
+                turn_id = call_turns.get(tool_id, "")
+            if not turn_id:
+                continue
+            assistant = assistants.setdefault(
+                turn_id,
+                {
+                    "content": [],
+                    "tool_calls": [],
+                    "tool_results": [],
+                    "timestamp": self._timestamp(event),
+                },
+            )
+            if loop_type == "content.part":
+                part = loop_event.get("part")
+                if isinstance(part, dict) and part.get("type") == "text":
+                    text = part.get("text")
+                    if isinstance(text, str) and text:
+                        assistant["content"].append(text)
+            elif loop_type == "tool.call":
+                name = loop_event.get("name")
+                if isinstance(tool_id, str) and isinstance(name, str):
+                    call_turns[tool_id] = turn_id
+                    assistant["tool_calls"].append(
+                        {
+                            "id": tool_id,
+                            "name": name,
+                            "input": self._tool_input(loop_event.get("args")),
+                        }
+                    )
+            elif loop_type == "tool.result":
+                if isinstance(tool_id, str):
+                    assistant["tool_results"].append(
+                        {
+                            "tool_use_id": tool_id,
+                            "content": self._tool_result(loop_event.get("result")),
+                        }
+                    )
+
+        for turn_id in list(assistants):
+            flush(turn_id)
+        return turns
+
+    def _last_assistant_text(self, session_file: Path | None) -> str:
+        if session_file is None:
+            return ""
+        for turn in reversed(self.parse_session_file(session_file)):
+            if turn.role == "assistant" and turn.content.strip():
+                return turn.content
+        return ""
+
+    @staticmethod
+    def _build_prompt(prompt: str, files: list[Path]) -> str:
+        if not files:
+            return prompt
+        refs = "\n".join(f"@{path}" for path in files)
+        return f"{prompt}\n\n{refs}"
+
+    @staticmethod
+    def _resolved_cwd(cwd: Path) -> Path:
+        return cwd.expanduser().resolve()
+
+    @staticmethod
+    def _mtime(path: Path) -> float:
+        try:
+            return path.stat().st_mtime
+        except OSError:
+            return 0
+
+    @staticmethod
+    def _timestamp(event: dict[str, Any]) -> datetime | None:
+        raw = event.get("time")
+        if not isinstance(raw, (int, float)):
+            return None
+        return datetime.fromtimestamp(raw / 1000, tz=UTC)
+
+    @staticmethod
+    def _text_blocks(raw: object) -> str:
+        if isinstance(raw, str):
+            return raw
+        if not isinstance(raw, list):
+            return ""
+        texts: list[str] = []
+        for block in raw:
+            if isinstance(block, str):
+                texts.append(block)
+            elif isinstance(block, dict) and isinstance(block.get("text"), str):
+                texts.append(block["text"])
+        return "\n".join(texts)
+
+    @staticmethod
+    def _tool_input(raw: object) -> object:
+        if not isinstance(raw, str):
+            return raw
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            return raw
+
+    @staticmethod
+    def _tool_result(raw: object) -> str:
+        if isinstance(raw, str):
+            return raw
+        if isinstance(raw, dict):
+            for key in ("output", "content"):
+                value = raw.get(key)
+                if isinstance(value, str):
+                    return value
+            return json.dumps(raw, ensure_ascii=False)
+        return "" if raw is None else str(raw)

{playmaker_cli-0.10.0 → playmaker_cli-0.11.0}/src/playmaker/cli.py

@@ -129,7 +129,7 @@ def skill_install(
 
 @app.command()
 def dispatch(
-    agent: str = typer.Argument(..., help="agent name (claude|codex|agy|gemini|opencode)"),
+    agent: str = typer.Argument(..., help="agent name (claude|codex|agy|gemini|kimi|opencode)"),
     prompt: str = typer.Option(..., "--prompt", "-p", help="initial prompt"),
     cwd: Path = typer.Option(
         Path.cwd(),

{playmaker_cli-0.10.0 → playmaker_cli-0.11.0}/src/playmaker/registry.py

@@ -9,6 +9,7 @@ from playmaker.agents.base import AgentHandler
 from playmaker.agents.claude import ClaudeHandler
 from playmaker.agents.codex import CodexHandler
 from playmaker.agents.gemini import GeminiHandler
+from playmaker.agents.kimi import KimiHandler
 from playmaker.agents.opencode import OpencodeHandler
 from playmaker.state import AGENTS_DIR
 
@@ -17,6 +18,7 @@ _HANDLERS: dict[str, AgentHandler] = {
     "codex": CodexHandler(),
     "agy": AgyHandler(),
     "gemini": GeminiHandler(),
+    "kimi": KimiHandler(),
     "opencode": OpencodeHandler(),
 }
 

playmaker_cli-0.11.0/tests/fixtures/kimi_wire.jsonl

@@ -0,0 +1,5 @@
+{"type":"turn.prompt","agentId":"main","input":[{"type":"text","text":"Create a file named hello.txt in the current directory containing the word OK, then reply DONE."}],"origin":{"kind":"user"},"promptId":"msg_01M1PEQAVTGFKDBPKVZN81AQ3H","time":1788533779323}
+{"type":"context.append_loop_event","agentId":"main","event":{"type":"tool.call","uuid":"5f6ff6da-1a1b-40ae-b083-19f79d71855e","turnId":"0","step":1,"stepUuid":"0d92aa4d-e201-44a7-82d2-69e088dbcc3d","toolCallId":"tool_b9dutdcTH3OmrVAuOyVX7lsg","name":"Write","args":{"path":"hello.txt","content":"OK"}},"time":1788533785040}
+{"type":"context.append_loop_event","agentId":"main","event":{"type":"tool.result","parentUuid":"5f6ff6da-1a1b-40ae-b083-19f79d71855e","toolCallId":"tool_b9dutdcTH3OmrVAuOyVX7lsg","result":{"output":"Wrote 2 bytes to hello.txt"}},"time":1788533785046}
+{"type":"context.append_loop_event","agentId":"main","event":{"type":"content.part","uuid":"a5e7ecd6-5067-4ff3-8d07-2cc468d6a0f5","turnId":"0","step":2,"stepUuid":"bbc61589-3b47-43a6-a129-e2d3380f0761","part":{"type":"text","text":"DONE"}},"time":1788533787715}
+{"type":"turn.ended","agentId":"main","turnId":0,"reason":"completed","durationMs":8392,"time":1788533787716}

playmaker_cli-0.11.0/tests/test_kimi.py

@@ -0,0 +1,333 @@
+"""Kimi handler: prompt-mode stream dispatch and wire transcript parsing."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import threading
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+import playmaker.config as config
+from playmaker.agents.kimi import KimiHandler
+from playmaker.registry import all_handlers, get_handler
+
+SESSION = "session_35f81bbc-3038-4bd3-96f1-ababeb5a86cb"
+NEWER_SESSION = "session_4c38d6a2-0579-4ff3-8d07-2cc468d6a0f5"
+FIXTURE = Path(__file__).parent / "fixtures" / "kimi_wire.jsonl"
+
+
+class _FakeStream:
+    def __init__(self, lines: list[str]) -> None:
+        self._lines = lines
+
+    def __iter__(self):
+        return iter(self._lines)
+
+    def read(self) -> str:
+        return "".join(self._lines)
+
+
+class _FakePopen:
+    """Stand-in for `kimi -p ... --output-format stream-json`."""
+
+    def __init__(self, lines: list[str], *, stderr: str = "", returncode: int = 0) -> None:
+        self._lines = lines
+        self._stderr = stderr
+        self.returncode = returncode
+        self.cmd: list[str] = []
+        self.kwargs: dict = {}
+        self.stdout = None
+        self.stderr = None
+
+    def __call__(self, cmd, **kwargs):
+        self.cmd = cmd
+        self.kwargs = kwargs
+        self.stdout = _FakeStream(self._lines)
+        self.stderr = _FakeStream([self._stderr])
+        return self
+
+    def wait(self) -> int:
+        return self.returncode
+
+
+class _ConcurrentStderrPopen:
+    """Requires stderr draining before its stdout stream can make progress."""
+
+    def __init__(self, lines: list[str], stderr: str) -> None:
+        self._lines = lines
+        self._stderr = stderr
+        self.returncode = 1
+        self.stderr_started = threading.Event()
+        self.stdout = None
+        self.stderr = None
+
+    def __call__(self, cmd, **kwargs):
+        class _Stderr(_FakeStream):
+            def read(stream_self) -> str:
+                self.stderr_started.set()
+                return super().read()
+
+        class _Stdout(_FakeStream):
+            def __iter__(stream_self):
+                assert self.stderr_started.wait(timeout=1), "stderr was not drained concurrently"
+                return super().__iter__()
+
+        self.stdout = _Stdout(self._lines)
+        self.stderr = _Stderr([self._stderr])
+        return self
+
+    def wait(self) -> int:
+        return self.returncode
+
+
+def _events(*objects: dict) -> list[str]:
+    return [json.dumps(obj) + "\n" for obj in objects]
+
+
+def _assistant(content: str | None = None, tool_calls: list[dict] | None = None) -> dict:
+    event: dict = {"role": "assistant"}
+    if content is not None:
+        event["content"] = content
+    if tool_calls is not None:
+        event["tool_calls"] = tool_calls
+    return event
+
+
+def _resume_hint() -> dict:
+    return {"role": "meta", "type": "session.resume_hint", "session_id": SESSION}
+
+
+@pytest.fixture
+def configured(monkeypatch):
+    def _set(cfg: dict) -> None:
+        monkeypatch.setattr(config, "load_config", lambda: cfg)
+
+    return _set
+
+
+@pytest.fixture(autouse=True)
+def isolated_kimi_home(monkeypatch, tmp_path) -> None:
+    monkeypatch.setenv("KIMI_CODE_HOME", str(tmp_path / "kimi-code"))
+
+
+def _install(monkeypatch, fake: _FakePopen) -> None:
+    monkeypatch.setattr("playmaker.agents.kimi.subprocess.Popen", fake)
+
+
+def test_dispatch_parses_stream_and_announces_the_late_session_id(monkeypatch, tmp_path) -> None:
+    fake = _FakePopen(
+        _events(
+            {"role": "meta", "type": "system.version", "version": "0.41.0"},
+            _assistant("Writing hello.txt."),
+            _assistant(
+                tool_calls=[
+                    {
+                        "type": "function",
+                        "id": "tool_1",
+                        "function": {"name": "Write", "arguments": '{"path":"hello.txt"}'},
+                    }
+                ]
+            ),
+            {"role": "tool", "tool_call_id": "tool_1", "content": "Wrote 2 bytes"},
+            _assistant("DONE"),
+            _resume_hint(),
+        )
+    )
+    _install(monkeypatch, fake)
+    seen: list[str] = []
+
+    result = KimiHandler().dispatch(prompt="do it", cwd=tmp_path, on_session_started=seen.append)
+
+    assert result.agent_session_id == SESSION
+    assert result.initial_output == "DONE"
+    assert seen == [SESSION]
+    assert fake.kwargs["cwd"] == str(tmp_path)
+
+
+def test_dispatch_uses_the_last_nonempty_assistant_content(monkeypatch, tmp_path) -> None:
+    fake = _FakePopen(
+        _events(_assistant("first"), _assistant("   "), _assistant("DONE"), _resume_hint())
+    )
+    _install(monkeypatch, fake)
+
+    result = KimiHandler().dispatch(prompt="p", cwd=tmp_path)
+
+    assert result.initial_output == "DONE"
+
+
+def test_missing_resume_hint_uses_the_per_cwd_session_listing(monkeypatch, tmp_path) -> None:
+    _install(monkeypatch, _FakePopen(_events(_assistant("DONE"))))
+    monkeypatch.setattr(KimiHandler, "_latest_session_id", lambda self, cwd: SESSION)
+    seen: list[str] = []
+
+    result = KimiHandler().dispatch(prompt="p", cwd=tmp_path, on_session_started=seen.append)
+
+    assert result.agent_session_id == SESSION
+    assert seen == [SESSION]
+
+
+def test_session_listing_uses_kimis_work_dir_field(monkeypatch, tmp_path) -> None:
+    class _Completed:
+        returncode = 0
+        stdout = json.dumps([{"id": SESSION, "workDir": str(tmp_path)}])
+
+    monkeypatch.setattr(
+        "playmaker.agents.kimi.subprocess.run", lambda *args, **kwargs: _Completed()
+    )
+
+    assert KimiHandler()._latest_session_id(tmp_path) == SESSION
+
+
+def test_session_listing_sorts_matching_entries_by_updated_at(monkeypatch, tmp_path) -> None:
+    class _Completed:
+        returncode = 0
+        stdout = json.dumps(
+            [
+                {"id": SESSION, "workDir": str(tmp_path), "updatedAt": 100},
+                {"id": NEWER_SESSION, "workDir": str(tmp_path), "updatedAt": 200},
+            ]
+        )
+
+    monkeypatch.setattr(
+        "playmaker.agents.kimi.subprocess.run", lambda *args, **kwargs: _Completed()
+    )
+
+    assert KimiHandler()._latest_session_id(tmp_path) == NEWER_SESSION
+
+
+def test_nonzero_exit_surfaces_stderr(monkeypatch, tmp_path) -> None:
+    fake = _FakePopen(
+        _events({"role": "meta", "type": "system.version", "version": "0.41.0"}),
+        stderr='error: failed to run prompt: Model "kimi-code/nope" is not configured',
+        returncode=1,
+    )
+    _install(monkeypatch, fake)
+
+    with pytest.raises(RuntimeError, match="kimi-code/nope"):
+        KimiHandler().dispatch(prompt="p", cwd=tmp_path)
+
+
+def test_large_stderr_is_drained_while_stdout_is_streamed(monkeypatch, tmp_path) -> None:
+    fake = _ConcurrentStderrPopen(
+        _events({"role": "meta", "type": "system.version", "version": "0.41.0"}),
+        "x" * 70_000 + " stderr detail",
+    )
+    _install(monkeypatch, fake)
+
+    with pytest.raises(RuntimeError) as exc_info:
+        KimiHandler().dispatch(prompt="p", cwd=tmp_path)
+
+    assert "stderr detail" in str(exc_info.value)
+    assert fake.stderr_started.is_set()
+
+
+def test_explicit_model_wins_and_prompt_mode_never_passes_approval_flags(
+    monkeypatch, tmp_path, configured
+) -> None:
+    configured({"agents": {"kimi": {"model": "kimi-code/configured"}}})
+    fake = _FakePopen(_events(_assistant("DONE"), _resume_hint()))
+    _install(monkeypatch, fake)
+
+    KimiHandler().dispatch(prompt="p", cwd=tmp_path, model="kimi-code/explicit")
+
+    assert fake.cmd[fake.cmd.index("-m") + 1] == "kimi-code/explicit"
+    assert fake.cmd[fake.cmd.index("-p") + 1] == "p"
+    assert fake.cmd[fake.cmd.index("--output-format") + 1] == "stream-json"
+    assert not {"--auto", "--yolo", "--plan"} & set(fake.cmd)
+
+
+def test_configured_model_is_used_when_no_model_is_passed(
+    monkeypatch, tmp_path, configured
+) -> None:
+    configured({"agents": {"kimi": {"model": "kimi-code/configured"}}})
+    fake = _FakePopen(_events(_assistant("DONE"), _resume_hint()))
+    _install(monkeypatch, fake)
+
+    KimiHandler().dispatch(prompt="p", cwd=tmp_path)
+
+    assert fake.cmd[fake.cmd.index("-m") + 1] == "kimi-code/configured"
+
+
+def test_no_model_flag_when_neither_dispatch_nor_config_supplies_one(
+    monkeypatch, tmp_path, configured
+) -> None:
+    configured({})
+    fake = _FakePopen(_events(_assistant("DONE"), _resume_hint()))
+    _install(monkeypatch, fake)
+
+    KimiHandler().dispatch(prompt="p", cwd=tmp_path)
+
+    assert "-m" not in fake.cmd
+
+
+def test_resume_uses_dash_s_and_keeps_the_session_id(monkeypatch, tmp_path) -> None:
+    fake = _FakePopen(_events(_assistant("DONE2"), _resume_hint()))
+    _install(monkeypatch, fake)
+
+    result = KimiHandler().resume(prompt="more", cwd=tmp_path, agent_session_id=SESSION)
+
+    assert fake.cmd[fake.cmd.index("-S") + 1] == SESSION
+    assert result.agent_session_id == SESSION
+
+
+def test_find_session_file_verifies_the_state_id_and_cwd(tmp_path) -> None:
+    cwd = tmp_path / "workspace"
+    cwd.mkdir()
+    home = Path(os.environ["KIMI_CODE_HOME"])
+    session_dir = home / "sessions" / "wd_workspace_0123456789ab" / SESSION
+    wire = session_dir / "agents" / "main" / "wire.jsonl"
+    wire.parent.mkdir(parents=True)
+    wire.write_text("", encoding="utf-8")
+    (session_dir / "state.json").write_text(
+        json.dumps({"id": SESSION, "cwd": str(cwd.resolve())}), encoding="utf-8"
+    )
+
+    assert KimiHandler().find_session_file(SESSION, cwd) == wire
+
+
+def test_find_session_file_without_state_uses_the_workspace_directory_name(tmp_path) -> None:
+    cwd = tmp_path / "workspace"
+    cwd.mkdir()
+    home = Path(os.environ["KIMI_CODE_HOME"])
+
+    def make_wire(workspace_name: str) -> Path:
+        wire = home / "sessions" / workspace_name / SESSION / "agents" / "main" / "wire.jsonl"
+        wire.parent.mkdir(parents=True)
+        wire.write_text("", encoding="utf-8")
+        return wire
+
+    matching_wire = make_wire("wd_workspace_0123456789ab")
+    make_wire("wd_other_abcdef012345")
+
+    handler = KimiHandler()
+    assert handler.find_session_file(SESSION, cwd) == matching_wire
+    assert handler.find_session_file(SESSION, tmp_path / "unrelated") is None
+
+
+def test_parse_session_file_maps_user_text_tools_and_assistant_text() -> None:
+    turns = KimiHandler().parse_session_file(FIXTURE)
+
+    assert [turn.role for turn in turns] == ["user", "assistant"]
+    assert turns[0].content.startswith("Create a file named hello.txt")
+    assert turns[0].timestamp is not None
+    assert turns[1].content == "DONE"
+    assert turns[1].tool_calls == [
+        {
+            "id": "tool_b9dutdcTH3OmrVAuOyVX7lsg",
+            "name": "Write",
+            "input": {"path": "hello.txt", "content": "OK"},
+        }
+    ]
+    assert turns[1].tool_results == [
+        {"tool_use_id": "tool_b9dutdcTH3OmrVAuOyVX7lsg", "content": "Wrote 2 bytes to hello.txt"}
+    ]
+
+
+def test_registry_exposes_kimi() -> None:
+    assert get_handler("kimi").name == "kimi"
+    assert "kimi" in all_handlers()