playmaker-cli 0.12.1__tar.gz → 0.14.0__tar.gz

{playmaker_cli-0.12.1 → playmaker_cli-0.14.0}/CHANGELOG.md

@@ -5,6 +5,112 @@ 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.14.0] - 2026-09-30
+
+### Added
+
+- **`--effort` for the `claude` lane.** `[agents.claude] effort = "xhigh"` or
+  `playmaker dispatch|continue … --effort <low|medium|high|xhigh|max>` is forwarded to
+  Claude Code's own `--effort`, right after `--model`, on dispatch and resume. The flag
+  overrides the config for one run (carried through `PLAYMAKER_CLAUDE_EFFORT`, never
+  persisted); an invalid value fails before any process starts; other lanes accept and
+  ignore it with a note.
+- **Banked limit resets in `playmaker quotas`.** The Codex block shows
+  `Banked resets  N (M usable now)` and each reset's expiry (from
+  `wham/rate-limit-reset-credits`, same bearer token). Claude's reset is not reachable
+  with the CLI token (CodexBar reads it from the web session) and stays out.
+- **The coach's ledger.** `scripts/ledger.py` keeps one JSON line per landed work package
+  in `~/.playmaker/ledger.jsonl` (`add`, `fix`, `escape`, `stats`, `tail`), and
+  `scripts/ledger-hook.py` — a Claude Code `PostToolUse` hook on `Bash` — writes the row
+  on every `git commit` from the WP's review directory, with an optional junior model
+  (`[ledger] junior = "codex:<model>"`) filling the soft fields. Fields, mapping and the
+  settings snippet: `references/ledger.md`.
+- **`--risk seams` in `review-board.sh`.** A one-seat board over the joints between the
+  work packages of one fan-out, after each passed its own board and the global gate.
+
+### Changed
+
+- **The coach skill, 2026-09-30 revision** (`skills/playmaker-coach`): routing is
+  «fit before headroom» (class the WP, then the ledger, then the pool floors, then
+  headroom); map vs. semantic recon; an integration step with a seam review before
+  landing; fixed board columns; a first-minute check on every detached dispatch and no
+  waiting on closed lanes; policy load order is personal, then repo. Reviewer roster
+  lines are an ordered preference list — the script seats exactly 1/2/3/1 for
+  routine/normal/high/seams after skipping the implementer and holds the rest in
+  reserve; fewer than required stops it (`PM_REVIEW_ALLOW_SHORT=1` overrides).
+- **`review-board.sh` protects its artefacts.** Previous verdicts are archived on a new
+  dispatch and ignored by `--collect` when older than the current patch; `--dry-run`
+  no longer truncates `sessions.txt`; untracked files under the review paths are listed
+  with the `git add -N` hint; `board.env` records risk, round and required count;
+  `--collect` marks `failed`/`killed` seats DEAD, parses the last object carrying the
+  contract, and prints `verdicts: k/N` (`BOARD INCOMPLETE` while short). The prompt
+  interpolates the base ref, forbids edits and scratch files inside the tree, tells a
+  seat that cannot run the gate to report it under `unverifiable`, and asks the `risk`
+  lens to falsify the acceptance criteria.
+
+### Fixed
+
+- **`playmaker quotas` no longer refreshes the Claude OAuth token.** The probe shared
+  the keychain entry and the single-use refresh token with the Claude Code CLI, and the
+  race logged the CLI out. The probe now only reads; when the token is expired it lets
+  the CLI refresh it (`[quotas] claude_refresh_via_cli`, default on) or shows
+  `login expired — run: claude auth login`. An outage after a successful refresh is
+  reported as an outage, not as an expired login.
+- **The reset-credits inventory is best-effort**: a failing secondary request no
+  longer sinks the whole Codex block.
+- **The ledger's writers take a lock and rewrites are atomic.** `ledger.py add` (and so
+  the hook) appends under an `flock`; `fix` and `escape` hold the same lock across their
+  read-modify-write and publish through a temp file and `os.replace`, so two coach sessions
+  committing at once cannot lose a row or tear the file; a trailing partial line is skipped
+  by the readers instead of stopping them. `--effort` is validated in the CLI before a
+  detached run spawns.
+
+## [0.13.0] - 2026-09-30
+
+### Added
+
+- **`muse` lane — Meta's Muse Code CLI as a first-class agent.**
+  `playmaker dispatch muse` runs `muse exec --json …`, and the session id
+  arrives in the **first** stdout line — unlike kimi, whose id comes last — so
+  `playmaker list` shows it at once. Resume re-runs `muse exec` with
+  `--session-id` in the same cwd, and `summary` reads
+  `${XDG_DATA_HOME:-~/.local/share}/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl`.
+  Permissions default to Muse's sandbox with approval off and the workspace
+  trusted (`--disable-approval --trust-workspace` — without trust Muse ignores
+  the repo's AGENTS.md), and `[agents.muse]` takes `binary`, `model`,
+  `reasoning_effort`, `yolo`, `trust_workspace`, `sandbox_network` and
+  `permission_profile`. Muse Spark is a senior-tier peer of codex, GLM and K3,
+  on its own `muse login`. No usage/quota API exists, so `playmaker quotas`
+  has no Muse block.
+
+### Fixed
+
+- **`playmaker quotas` printed `unsupported` for Kimi Code.** By 2026-09-29
+  the `/usages` endpoint stopped returning the `user` object — and with it
+  `membership.level` — and the probe required it, so a payload whose `usage`
+  and `limits[]` buckets were unchanged was rejected as unrecognised. `user`
+  is now optional (when present it must still be an object), so the Session
+  and Weekly rows render again; the `Kimi Code` header goes without the tier
+  the API no longer reports. The new `usages` block (`limit_5h`/`limit_7d`
+  with `used_ratio`) is not read: on the live account it said 0 while `usage`
+  counted 21 used.
+- **`playmaker quotas` printed an error for Antigravity while agy worked.**
+  Two things broke at once. agy 1.2's embedded language server now refuses a
+  request without its CSRF token (401 `missing CSRF token`), and an agy someone
+  else started keeps that token to itself, so the local path found nothing it
+  could read. The remote fallback (`retrieveUserQuota`, ideType ANTIGRAVITY)
+  meanwhile began answering 403 "You do not have a valid license of this
+  product". The probe now starts a short-lived agy of its own when no running
+  one answers — headless (`--input-format stream-json -p=` waits on stdin, so
+  no TTY and no request spent), with a token it chose, in an empty scratch
+  directory, stopped as a process group once the summary is in (about 1.5 s;
+  capped at 12 s) — and reads the full Gemini and Claude/GPT 5h/weekly
+  windows off it. Process discovery also matches `agy-real`, the binary
+  behind an `agy` wrapper. If both sources still fail and the remote says "no
+  valid license", the block reads `unavailable` with a hint and keeps its last
+  success instead of `error`; any other remote failure is still an error. A
+  remote fallback now says why the daemon was missed.
+
 ## [0.12.1] - 2026-09-08
 
 ### Fixed

playmaker_cli-0.12.1/README.md → playmaker_cli-0.14.0/PKG-INFO

@@ -1,3 +1,30 @@
+Metadata-Version: 2.5
+Name: playmaker-cli
+Version: 0.14.0
+Summary: Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity, Kimi Code, Muse 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,kimi,kimi-code,muse,muse-code,opencode,orchestration,subagents
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.27.0
+Description-Content-Type: text/markdown
+
 # playmaker
 
 [![CI](https://github.com/vladsafedev/playmaker/actions/workflows/ci.yml/badge.svg)](https://github.com/vladsafedev/playmaker/actions/workflows/ci.yml)
@@ -5,7 +32,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, Kimi Code and opencode as parallel sub-agents from one terminal — and spend separate quotas instead of one.**
+**Run Claude Code, Codex, Antigravity, Kimi Code, Muse 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,11 +74,13 @@ 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, 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.
+2. **Provider arbitrage.** Codex, Antigravity, Kimi Code, Muse 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; Muse Code adds Meta's senior-tier Muse Spark on its own
+   login.
    `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
@@ -124,6 +153,11 @@ The other agents differ, because their CLIs do:
   `--auto`, `--yolo` and `--plan`, and already runs with auto-approval, so
   there is no read-only mode below the prompt.
 
+- **muse** runs sandboxed by default with approval off and the workspace
+  trusted (`--disable-approval --trust-workspace`). The sandbox denies writes
+  outside the repo, so `uv run`, npm and similar caches fail inside it — set
+  `yolo = true` if workers must run such gates.
+
 - **gemini** (legacy) runs with `--yolo`.
 
 ## Install
@@ -162,6 +196,7 @@ playmaker agents          # which agent CLIs are reachable
 | **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` |
+| **Muse Code CLI** | `curl -fsSL https://dev.meta.ai/install.sh \| sh` | self-updating launcher in `~/.local/bin` (point `[agents.muse] binary` at it if a detached dispatch can't find it); log in once with `muse login` or set `META_API_KEY`; `--model muse-spark-1.3` — omit it and Muse's own default from `~/.config/muse/settings.json` applies |
 | **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.
@@ -297,6 +332,7 @@ and locates the session file the tool writes locally. Empirically:
 | 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) |
+| muse | `${XDG_DATA_HOME:-~/.local/share}/muse/sessions/YYYY/MM/DD/<session-uuid>/session.jsonl` (the date directory is the session's creation date; a resume appends to the same file) |
 | 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
@@ -339,6 +375,16 @@ A bare name is resolved on `PATH`; a path is used as-is. opencode installs to
 `.zshrc` — so a dispatch from cron, an editor, or the coach can't find it
 otherwise, and playmaker would report the agent as unavailable.
 
+**claude** also accepts an effort level — Claude Code's `--effort
+low|medium|high|xhigh|max`, which trades speed for reasoning depth (the
+motivating case: running Opus review boards at `xhigh`). Set the lane default
+once with `effort = "xhigh"` under `[agents.claude]`; `playmaker dispatch
+claude --effort <level>` and `playmaker continue <id> --effort <level>`
+override it for one run without persisting anything. The flag is accepted and
+ignored on every other lane so scripts can pass it uniformly, and when it is
+unset everywhere no `--effort` flag is sent at all — Claude Code's own default
+applies.
+
 ## Notifications
 
 Every detached dispatch pings when it finishes. With
@@ -400,9 +446,13 @@ The `Weekly`, `Weekly · Fable` and `Sonnet` rows above are the point: they are
 **separate buckets**. So is the `Codex — Spark` block, every agy row, and the
 whole Z.ai block. Routing a subtask is choosing which of them to spend.
 
-- **Claude** — OAuth usage API; token from the Claude Code Keychain entry.
+- **Claude** — OAuth usage API; token from the Claude Code Keychain entry. When
+  it expires, Claude Code itself refreshes it; the quota probe never rotates the
+  shared refresh token.
   Model-scoped weekly buckets come from the usage API's `limits[]` array and
   print as `Weekly · <model>`.
+  `[quotas] claude_refresh_via_cli` defaults to `true`; set it to `false` to
+  report `login expired — run: claude auth login` without spawning `claude`.
 - **Codex** — ChatGPT `wham/usage` API; token from `~/.codex/auth.json`. The
   Spark model's own 5-hour and weekly windows come from
   `additional_rate_limits[]` and print as their own `Codex — Spark` block.
@@ -423,6 +473,9 @@ whole Z.ai block. Routing a subtask is choosing which of them to spend.
   `~/.kimi-code/credentials/kimi-code-env-*.json` (`$KIMI_CODE_HOME` overrides
   the root). Its 5-hour `Session` and weekly rows are separate percentage
   buckets; no credential reads as *unsupported* rather than a failed probe.
+- **Muse Code** — no usage or quota API exists (billing is pay-as-you-go or a
+  subscription via accountscenter.meta.com), so `playmaker quotas` has no Muse
+  block.
 
 Reading these at *model* granularity is the point: they are the load-balancing
 input the coach skill uses to route each subtask.

playmaker_cli-0.12.1/PKG-INFO → playmaker_cli-0.14.0/README.md

@@ -1,30 +1,3 @@
-Metadata-Version: 2.5
-Name: playmaker-cli
-Version: 0.12.1
-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,kimi,kimi-code,opencode,orchestration,subagents
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development
-Classifier: Topic :: Utilities
-Requires-Python: >=3.11
-Requires-Dist: rich>=13.7
-Requires-Dist: typer>=0.27.0
-Description-Content-Type: text/markdown
-
 # playmaker
 
 [![CI](https://github.com/vladsafedev/playmaker/actions/workflows/ci.yml/badge.svg)](https://github.com/vladsafedev/playmaker/actions/workflows/ci.yml)
@@ -32,7 +5,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, Kimi Code and opencode as parallel sub-agents from one terminal — and spend separate quotas instead of one.**
+**Run Claude Code, Codex, Antigravity, Kimi Code, Muse 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,11 +47,13 @@ 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, 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.
+2. **Provider arbitrage.** Codex, Antigravity, Kimi Code, Muse 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; Muse Code adds Meta's senior-tier Muse Spark on its own
+   login.
    `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
@@ -151,6 +126,11 @@ The other agents differ, because their CLIs do:
   `--auto`, `--yolo` and `--plan`, and already runs with auto-approval, so
   there is no read-only mode below the prompt.
 
+- **muse** runs sandboxed by default with approval off and the workspace
+  trusted (`--disable-approval --trust-workspace`). The sandbox denies writes
+  outside the repo, so `uv run`, npm and similar caches fail inside it — set
+  `yolo = true` if workers must run such gates.
+
 - **gemini** (legacy) runs with `--yolo`.
 
 ## Install
@@ -189,6 +169,7 @@ playmaker agents          # which agent CLIs are reachable
 | **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` |
+| **Muse Code CLI** | `curl -fsSL https://dev.meta.ai/install.sh \| sh` | self-updating launcher in `~/.local/bin` (point `[agents.muse] binary` at it if a detached dispatch can't find it); log in once with `muse login` or set `META_API_KEY`; `--model muse-spark-1.3` — omit it and Muse's own default from `~/.config/muse/settings.json` applies |
 | **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.
@@ -324,6 +305,7 @@ and locates the session file the tool writes locally. Empirically:
 | 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) |
+| muse | `${XDG_DATA_HOME:-~/.local/share}/muse/sessions/YYYY/MM/DD/<session-uuid>/session.jsonl` (the date directory is the session's creation date; a resume appends to the same file) |
 | 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
@@ -366,6 +348,16 @@ A bare name is resolved on `PATH`; a path is used as-is. opencode installs to
 `.zshrc` — so a dispatch from cron, an editor, or the coach can't find it
 otherwise, and playmaker would report the agent as unavailable.
 
+**claude** also accepts an effort level — Claude Code's `--effort
+low|medium|high|xhigh|max`, which trades speed for reasoning depth (the
+motivating case: running Opus review boards at `xhigh`). Set the lane default
+once with `effort = "xhigh"` under `[agents.claude]`; `playmaker dispatch
+claude --effort <level>` and `playmaker continue <id> --effort <level>`
+override it for one run without persisting anything. The flag is accepted and
+ignored on every other lane so scripts can pass it uniformly, and when it is
+unset everywhere no `--effort` flag is sent at all — Claude Code's own default
+applies.
+
 ## Notifications
 
 Every detached dispatch pings when it finishes. With
@@ -427,9 +419,13 @@ The `Weekly`, `Weekly · Fable` and `Sonnet` rows above are the point: they are
 **separate buckets**. So is the `Codex — Spark` block, every agy row, and the
 whole Z.ai block. Routing a subtask is choosing which of them to spend.
 
-- **Claude** — OAuth usage API; token from the Claude Code Keychain entry.
+- **Claude** — OAuth usage API; token from the Claude Code Keychain entry. When
+  it expires, Claude Code itself refreshes it; the quota probe never rotates the
+  shared refresh token.
   Model-scoped weekly buckets come from the usage API's `limits[]` array and
   print as `Weekly · <model>`.
+  `[quotas] claude_refresh_via_cli` defaults to `true`; set it to `false` to
+  report `login expired — run: claude auth login` without spawning `claude`.
 - **Codex** — ChatGPT `wham/usage` API; token from `~/.codex/auth.json`. The
   Spark model's own 5-hour and weekly windows come from
   `additional_rate_limits[]` and print as their own `Codex — Spark` block.
@@ -450,6 +446,9 @@ whole Z.ai block. Routing a subtask is choosing which of them to spend.
   `~/.kimi-code/credentials/kimi-code-env-*.json` (`$KIMI_CODE_HOME` overrides
   the root). Its 5-hour `Session` and weekly rows are separate percentage
   buckets; no credential reads as *unsupported* rather than a failed probe.
+- **Muse Code** — no usage or quota API exists (billing is pay-as-you-go or a
+  subscription via accountscenter.meta.com), so `playmaker quotas` has no Muse
+  block.
 
 Reading these at *model* granularity is the point: they are the load-balancing
 input the coach skill uses to route each subtask.

{playmaker_cli-0.12.1 → playmaker_cli-0.14.0}/pyproject.toml

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

{playmaker_cli-0.12.1 → playmaker_cli-0.14.0}/skills/playmaker-coach/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: playmaker-coach
-description: Team-lead mode for coding work. Decompose the task into work packages, dispatch them to Claude/Codex/Antigravity(agy)/opencode/Kimi Code(kimi) workers through the `playmaker` CLI, then run an automatic multi-agent review board over every diff before it lands, and drive the fix cycles. Use for ANY request that will change code in more than one place, needs an independent review pass, or has two or more parts that can run at once — "implement", "add", "fix", "refactor", "wire up", "сделай", "почини", "добавь", "реализуй", "собери". NOT for answering a question, reading or explaining code, a single-line edit, or a git/ops command.
+description: Team-lead mode for coding work. Decompose the task into work packages, dispatch them to Claude/Codex/Antigravity(agy)/opencode workers through the `playmaker` CLI, then run an automatic multi-agent review board over every diff before it lands, and drive the fix cycles. Use for ANY request that will change code in more than one place, needs an independent review pass, or has two or more parts that can run at once — "implement", "add", "fix", "refactor", "wire up", "сделай", "почини", "добавь", "реализуй", "собери". NOT for answering a question, reading or explaining code, a single-line edit, or a git/ops command.
 ---
 
 # playmaker-coach — you are the tech lead, not the typist
 
-`playmaker` dispatches sub-tasks to Codex / Antigravity (`agy`) / opencode / Kimi Code (`kimi`) / a
-sibling Claude, tracks them, and returns their threads. This skill is the judgment on top: what to
-split, who gets which slice, how to size it so verifying is cheap, and **how the review board runs**.
+`playmaker` dispatches sub-tasks to Codex / Antigravity (`agy`) / opencode / a sibling Claude,
+tracks them, and returns their threads. This skill is the judgment on top: what to split,
+who gets which slice, how to size it so verifying is cheap, and **how the review board runs**.
 
 **The coach produces plans, prompts, verdicts and integration — not feature diffs.** Your context
 window is the most expensive resource on the table. Every file you read yourself and every line you
@@ -17,9 +17,9 @@ summarization, and even the drafting of worker prompts when the task is big enou
 Two loops run under your hand, always both:
 
 ```
-decompose → dispatch → prove on disk → REVIEW BOARD → adjudicate → continue → land
-                                            ↑______________________|
-                                                 max 2 cycles
+decompose → dispatch → prove on disk → REVIEW BOARD → adjudicate → continue
+                                            ↑______________________|   max 2 cycles
+all WPs green → integrate → GLOBAL GATE → SEAM REVIEW (≥2 interacting WPs) → land → ledger row
 ```
 
 ## 1. Activation gate
@@ -47,21 +47,29 @@ outside the skill so it survives `playmaker skill install --force`. Read, in thi
 later files override earlier ones:
 
 ```bash
-cat ./.playmaker/policy.md      2>/dev/null   # repo policy (gates, protected paths, conventions)
-cat ~/.playmaker/policy.md      2>/dev/null   # personal policy (quota economics, lane defaults)
+cat ~/.playmaker/policy.md      2>/dev/null   # personal policy (tiers, quota economics, lane defaults)
+cat ./.playmaker/policy.md      2>/dev/null   # repo policy (gates, protected paths, conventions) — wins
 ls  ./.playmaker/agents/*.md    2>/dev/null || ls ~/.playmaker/agents/*.md 2>/dev/null
 ```
 
-Agent profiles describe each lane's strengths, ceiling, and quota position — trust a profile over
-the generic defaults here. If no policy file exists, say so once in the plan and use these defaults.
+Agent profiles describe each lane's traps, mechanics and quota position — trust a profile over the
+generic defaults here, never over the policy's tier table or a dated owner order: profiles say how a
+lane behaves, policy says what it may be given. A newer dated order beats an older line anywhere. If no policy file exists, say so once in the plan and use these defaults.
 
 ## 3. Protocol
 
 ### 3.1 Recon — delegate it
 
-Codebase exploration is the highest-leverage thing to delegate: raw reading is exactly what the
-cheapest model does as well as you do. Before your own `grep`/`Read` sweep, dispatch a read-only
-recon with an explicit deliverable and `--sync`, and read a 200-word report instead of ten files:
+Codebase exploration is the highest-leverage thing to delegate. Two kinds, two tiers:
+
+- **Map recon** — locate files, symbols, call sites, line ranges, inventories. Raw reading: the
+  cheapest lane (Gemini Flash) does it as well as you do.
+- **Semantic recon** — invariants, ownership, contracts, side effects, impact radius, «why is it like
+  this». Judgment: a senior lane (Kimi K3 for many-file sweeps, Gemini Pro, Codex). A cheap model
+  returns a confident wrong map, and you plan on it.
+
+Before your own `grep`/`Read` sweep, dispatch the matching kind with an explicit deliverable and
+`--sync`, and read a 200-word report instead of ten files:
 
 ```bash
 playmaker dispatch agy --model <cheap-tier> --cwd "$(pwd)" --sync --read-only \
@@ -77,14 +85,17 @@ playmaker quotas               # capacity per MODEL, not per agent; re-probes it
 ```
 
 Read at model granularity: separate buckets inside one provider are separate capacity. The aim is
-**level-loading** — finish the week with every pool drawn down evenly, except the one reserved for
-the coach — not hoarding the pools other people also use. Details and per-provider quirks:
+**accepted work per point of scarce quota**, with prepaid capacity spent before it resets.
+Level-loading — every pool drawn down evenly by week's end, except the coach's own — is the
+tie-breaker between lanes that fit a WP equally, never a reason to queue a WP behind a closed lane. Details and per-provider quirks:
 `references/quotas.md`.
 
 ### 3.3 Decompose into work packages
 
-2–5 WPs on the first pass. A WP is dispatchable only when all five hold — this is what makes review
-cheap and re-prompting rare:
+2–5 WPs on the first pass. Name each WP's **class** first — `mechanical | feature | terminal-heavy |
+repo-recon | architecture | high-risk` — it decides which senior lanes are eligible (policy: fit before
+headroom), which lenses the board gets, and it is the first field of the ledger row. Then a WP is
+dispatchable only when all five hold — this is what makes review cheap and re-prompting rare:
 
 1. **Hard file boundary.** "Edit only `x.ts` and its spec" — never "do the backend part".
 2. **A gate the worker runs itself** — `tsc --noEmit`, a named spec file, a lint pass. It must exit 0
@@ -104,7 +115,7 @@ policy first, then `references/lanes.md`.
 
 ### 3.4 Propose, then wait
 
-Post the plan as: WP → lane+model → why → gate → done-condition, plus the reviewer pair per WP and
+Post the plan as: WP → class → lane+model → why → gate → done-condition, plus the reviewer pair per WP and
 the current per-model capacity. **Dispatch nothing until the user approves.** Approval may be
 partial ("go but reroute tests"); restate the modified plan in one line, then dispatch.
 
@@ -118,19 +129,27 @@ playmaker dispatch <agent> --model <name> --batch "$B" --cwd "$(pwd)" --prompt "
 Detached by default — that is the point; never `--sync` a whole fan-out. Always pass `--cwd`,
 `--batch` (one summary ping for the batch), and `--model` unless the profile says otherwise.
 Prompt shape: `references/prompt-templates.md`. Per-agent traps (agy scratch dir, opencode relative
-paths, codex model roster, kimi's K2.7 default and exit codes): `references/agent-gotchas.md`.
+paths, codex model roster): `references/agent-gotchas.md`.
 
 Parallel WPs that touch the same files go in **git worktrees**, one per WP, or they will collide.
 
+Within a minute of every detached dispatch, `playmaker get <id> --json`: a quota or auth refusal
+finishes in seconds as `failed`, pings nobody, and looks exactly like a slow worker. Give every
+dispatch a deadline (recon 15 minutes; a WP by its size) and on expiry check the process is alive
+(`playmaker logs <id>`, its RSS) before waiting longer. Never wait for a closed lane.
+
 ### 3.6 Prove it on disk before you believe it
 
 `done` means "the process exited cleanly with text", not "code changed". playmaker ≥0.9 marks a
 zero-change write task `no_changes` — treat it exactly as a failure. On older builds, check yourself:
 
 ```bash
-git -C "<cwd>" status --short        # empty tree on a write WP = NOT done
+git -C "<cwd>" status --short --untracked-files=all   # empty tree on a write WP = NOT done
 ```
 
+New files are invisible to `git diff`: `git add -N <new files>` before the board, and compare
+`git diff --stat` with what the worker claims it changed.
+
 Then run the WP's own gate yourself, once, cheaply. A WP that fails its gate never reaches the
 review board — it goes straight back to the worker.
 
@@ -156,10 +175,18 @@ Non-negotiables:
 - Every finding carries `file:line` + a concrete failure scenario. **No evidence → dropped.** You
   arbitrate, and a reviewer's confidence is an input, not a verdict.
 - Fixes go back via `playmaker continue <impl-id>` as a numbered list — the worker still has its
-  context. Re-review runs on the **delta only**.
+  context. Re-review runs on the **delta only** — which means passing the round-1 state as the
+  base-ref (a wip commit in the worktree, squashed before landing); with the original base the
+  patch is cumulative and reviewers re-open settled code.
+- A ruling that changes the scope goes into `spec.md` before the next round — reviewers refute
+  against the spec, and a stale spec produces false blockers. Before charging a finding to the
+  worker, check it is not already present on the base ref.
 - **Two cycles maximum.** Still blocking after two → stop and escalate to the user with both
   verdicts. A third round at the same lane is the most expensive way to use a cheap model.
 - Land only at **zero blocking findings**.
+- On `high`, the `risk` seat is told to **falsify** the acceptance criteria — a command, input or repro
+  per criterion it attacked, not only an argument; its `pass` lists what it tried. A seat that cannot
+  execute (the `claude` lane runs with binaries forbidden) never holds `correctness` — give it `contracts`.
 
 ### 3.8 Keep a board file
 
@@ -172,11 +199,39 @@ Long fan-outs outlive your context. Maintain `./.playmaker/board.md` — one row
 Update it at dispatch, at gate, after each review round. On resume, read the board before anything
 else. It is also what you paste back to the user as the status report.
 
+The columns are fixed — one layout, not one per board: a resumed session and the ledger both parse
+them. At landing, the ledger hook writes the WP's row to the cross-repo ledger on `git commit`; read its
+`[ledger]` line and correct the soft fields with `python3 ~/.playmaker/scripts/ledger.py fix wp=… k=v`.
+When the hook matched nothing, append the row by hand: `python3 ~/.playmaker/scripts/ledger.py add
+wp=… class=… impl_lane=… …` (fields: `~/.playmaker/policy.md`, «Ledger»). It keeps what board prose loses: class, first-gate pass, blocking findings that survived
+adjudication, cycles, wall time — the evidence the routing step reads.
+
 ### 3.9 Failures
 
-Surface them; never silently retry. A failed dispatch (missing binary, bad auth, rejected model)
-gets a re-routed plan proposed to the user, not a second attempt at the same string. Diagnosis per
-agent: `references/agent-gotchas.md`.
+Surface them; never silently retry — and never wait. A failed dispatch (missing binary, bad auth,
+rejected model, quota) is neither a fix cycle nor a worker failure: re-route the WP to the next live
+senior lane now, with the full context in a fresh prompt, and record the substitution in the board.
+Ask the user only when no eligible lane is left. Diagnosis per agent: `references/agent-gotchas.md`.
+
+### 3.10 Integrate before landing — when the fan-out had two or more WPs
+
+Two green WPs can be wrong together. Per-WP gates and boards prove the parts; nothing above proves the
+whole. Once every WP is green:
+
+```
+integrate on one tree (worktrees merged in dependency order)
+  → GLOBAL GATE — the repo's minimum bar plus the union of the WPs' own gates, run by you
+  → if ≥2 WPs touched interacting modules:
+      SEAM REVIEW — pm-review <batch>-seams <base-before-first-WP> --risk seams --impl-agent <main lane>
+  → commit, one WP per commit, in integration order → ledger rows
+```
+
+"Interacting" = shared types or packages, the same service or screen, a migration and its consumers,
+event or config names, shared state. The seam reviewer gets a spec that lists the seams and reads only
+those: changed interfaces, duplicated or conflicting assumptions, incompatible types, migration order,
+naming, config, shared state. The packages' internals already passed their own boards — re-reviewing
+them is the third round the protocol forbids. Roster: the `seams` block in `reviewers.conf`;
+`--impl-agent` is the lane that implemented most of the fan-out.
 
 ## 4. What the coach may still type by hand
 
@@ -209,3 +264,6 @@ editor on product code, ask whether that is a WP you failed to write.
 - **Dispatching a WP you cannot verify in one command and one paragraph.**
 - **Omitting `--model`** and letting a CLI default drain a top-tier bucket.
 - **Reading whole agent threads** when `summary` answers the question.
+- **Landing two green WPs without running the tree they make together.** Per-WP gates prove the
+  parts; the global gate and the seam review prove the whole.
+- **Routing by headroom alone.** Class first, then the ledger's floor, then the pool floors, then headroom.

{playmaker_cli-0.12.1 → playmaker_cli-0.14.0}/skills/playmaker-coach/references/agent-gotchas.md

@@ -65,22 +65,6 @@ 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