claude-dev-env 8.85.3 → 8.86.0

package/.agents/skills/efficient-review/README.md

@@ -0,0 +1,44 @@
+# One installed copy
+
+This package holds the one copy of efficient-review, at `packages/claude-dev-env/.agents/skills/efficient-review/`. A fresh install copies that directory to `~/.claude/skills/efficient-review` and `~/.agents/skills/efficient-review`.
+
+A session in any repository runs the review from that installed directory. It does not check out a second repository, name a workflow, or read a credential.
+
+## Plan
+
+From the skill directory:
+
+```
+python -m tools.efficient_review plan
+```
+
+On Claude, `CLAUDECODE` or `CLAUDE_CODE_ENTRYPOINT` is set and Cursor and Codex markers are absent. The plan selects haiku and the slim profile from `hooks_constants.haiku_spawn_slim_gate_constants`, and prints the headless command and its environment. Run that command. Send the review task on standard input. The criteria are in [reference/criteria.md](reference/criteria.md).
+
+On any other platform, including a plain shell, the plan defers the model. The running agent follows [SKILL.md](SKILL.md) and picks the model.
+
+The constants module is the copy installed with this package's hooks, at `hooks/hooks_constants/haiku_spawn_slim_gate_constants.py` next to the skills directory, or inside a checkout of this package. The plan does not carry a second profile.
+
+## A local job in another repository
+
+A repository that wants a job to run the review writes that job itself. This package does not ship one. The job runs the same plan from the installed skill directory, then follows [SKILL.md](SKILL.md).
+
+```yaml
+- name: Plan the review
+  working-directory: the installed skill directory
+  run: python -m tools.efficient_review plan
+```
+
+## What a consuming repository deletes
+
+Delete the vendored skill and the runner that existed only to launch it:
+
+- `.claude/skills/efficient-review/`
+- `tools/efficient_review.py`
+- `tools/efficient_review_launch.py`
+- `tools/efficient_review_request.py`
+- `tools/config/efficient_review_constants.py`
+- `.claude/hooks/efficient_review_model_gate.py`
+- `.claude/hooks/efficient_review_model_gate.sh`
+- `.claude/hooks/config/efficient_review_model_gate_constants.py`
+
+Also delete a vendored slice of `tools/review_profile`, `tools/review_command`, `tools/review_rules`, `tools/review_stream`, and `tools/review_codex` when that slice exists only so the old runner could import it. Delete a settings file whose keys named a workflow, a checkout credential, a roster, or a broker. Keep `tools/review_model_eval` when the repository still grades reviews with it.

package/.agents/skills/efficient-review/SKILL.md

@@ -1,79 +1,32 @@
 ---
 name: efficient-review
 description: >-
-  Run one low-cost code review of the current branch, or of a branch in another
-  repository, as a headless Claude run on haiku with the slim review profile.
-  An auto run lets the account broker pick the account. A headless run names
-  the account. Triggers: /efficient-review, "efficient review", "cheap review",
-  "haiku review of this branch".
+  Review the current branch from the installed skill. On Claude, the plan
+  selects haiku and the slim profile. On any other platform, the running agent
+  follows the criteria and picks the model. Triggers: /efficient-review,
+  "efficient review", "cheap review".
 ---
 
 # Efficient review
 
-This skill runs one headless code review of a branch on haiku and prints its findings. Pick the mode, run the planner, then run the review on the machine that holds the Claude accounts, or through the agent-pc runner from a cloud session.
+Review the current branch with the criteria in [reference/criteria.md](reference/criteria.md). From this directory, run `python -m tools.efficient_review plan`. The plan names the runtime. This skill makes no network call.
 
-Argument shape: `/efficient-review [auto|headless] [account] [model=] [effort=] [level=] [base=]`. Pass `model=` only as the Defaults section allows.
-A blank argument comes from [`defaults.json`](defaults.json).
+## Claude
 
-## Defaults
+When the plan runtime is `claude`, the model is haiku and the profile is the slim profile in `hooks_constants.haiku_spawn_slim_gate_constants`. Run the printed command and send the review task on standard input. See [reference/criteria.md](reference/criteria.md).
 
-**Always run the review on haiku.** `defaults.json` names `haiku`, and a blank `model` input runs it. Pass `model=` or the workflow's `model` input only when the owner's own message names the family as a directive, such as "run this review on sonnet". Then run it on that family. Do not ask which model to use. Do not change the model on your own, for depth, for cost, or because passes keep finding issues. A stream of findings is a reason to fix the findings and run haiku again.
+## Other platforms
 
-**The review must run headless.** Never spawn the review as an Agent subagent in this session. A subagent runs inside the parent session, so it cannot load the slim profile's setting sources, plugin folder, MCP config, or auto-compact window. `defaults.json` holds a headless mode, and `load_defaults` refuses any other mode.
+When the plan runtime is `other`, the model is deferred. The running agent applies [reference/criteria.md](reference/criteria.md) and picks the model.
 
-## Subcommands
+## Loop
 
-Run each one as `python -m tools.efficient_review <subcommand> <arguments>` from the checkout that contains `tools/efficient_review.py`.
-
-| Subcommand | Action |
-|---|---|
-| `plan` | Prints the mode, account, model family, harness, effort, level, base, and the prompt. |
-| `accounts` | Lists the Claude accounts a headless run can name. |
-| `run` | Runs a headless or auto review and prints the review, the served models, and the saved file. |
-
-## Modes
-
-| Mode | Picked when | Account |
-|---|---|---|
-| auto | No mode word and no account. The word `auto` picks it too. | The account broker picks it. Ask nothing. |
-| headless | The word `headless`, or an account launcher name. | Required. With no account named, ask for one. |
-
-A model is a family name: haiku, sonnet, opus, sol, or luna. The planner refuses a versioned model ID. `codex review` takes no level, so the planner refuses `level=` with sol or luna.
-
-## 1. Headless mode with no account
-
-Run `python -m tools.efficient_review accounts`. Ask with the session's question tool, one option per listed account, and wait for the answer. The answer is the account. On the machine that holds the launchers, the list comes from the `claude-*.cmd` launchers, without `claude-base`, `claude-raw`, and `claude-kimi`. In the cloud the list is the known roster.
-
-## 2. Headless or auto on that machine
-
-Run `python -m tools.efficient_review run <arguments> --repository <checkout>`. When the checkout has no launcher folder, go to step 3.
-
-- It builds the slim profile from `tools.review_profile` into a temp folder.
-- Auto asks `account_broker.py choose --product claude` for the account.
-- It runs the account launcher with `-p`, the model alias, the effort, the profile arguments, and the environment. The system prompt file holds the review rules from the checkout that contains the runner, and the code standards. The prompt and the diff against the base go on standard input.
-- A sol or luna family runs `codex review` on the newest slug of that family. The log prints that slug.
-- It prints the review, the served models from the stream's `modelUsage` keys, and the saved file. The review and its record go to a temp folder outside the repository.
-
-## 3. Headless or auto from a cloud session
-
-The cloud container has no other Claude accounts, so the review runs on the agent-pc runner. Read [reference/cloud-session.md](reference/cloud-session.md).
+Check each finding against the code. Fix every one that holds. Run the review again until a pass reports none. The steps are in [reference/criteria.md](reference/criteria.md).
 
 ## Reading guide
 
 | File | What it does |
 |---|---|
-| [`reference/cloud-session.md`](reference/cloud-session.md) | Dispatching the review from a cloud session and reading its results branch. |
-| [`defaults.json`](defaults.json) | The default model family, effort, level, prompt, base, profile, advisor, validator, mode, and timeout. |
-
-## Common pitfalls
-
-- **Picking a stronger model after several passes.** Fix the findings and run haiku again.
-- **Setting a valid finding aside.** Check each finding against the code. Fix every one that holds in the same branch, even when it reaches files the diff did not touch. Answer only the findings that fail the check, with the file and line that rules each out.
-- **Asking which model to use.** The answer is haiku. When the owner names another family, run it without a confirmation question.
-- **Spawning the review as a subagent.** The review loses the slim profile. Run it headless.
-- **Dispatching from the branch under review.** The workflow runs only from `main`.
-
-## Out of scope
-
-- The `validator` default stays `off`.
-- A fixer step after the review. The skill has no fixer step.
+| [README.md](README.md) | How a session loads this copy, and the shape of a local job a repository may write. |
+| [reference/criteria.md](reference/criteria.md) | The review criteria, the finding block, and the loop. |
+| [tools/efficient_review.py](tools/efficient_review.py) | `plan` prints the runtime selection. |

package/.agents/skills/efficient-review/reference/criteria.md

@@ -0,0 +1,21 @@
+# Review criteria
+
+Apply these to the diff. Report a finding only after checking it against the code.
+
+- Review supported behavior and the changed repository contract. Current instructions override a stale copy. A contract change is not a defect because an older rule differs.
+- Name a reachable caller, a supported input, and an observable failure for each defect.
+- Check command flags, the environment, the pipeline, and the executable path before calling a command read-only.
+- Security and atomicity findings need deployment and trust-boundary evidence.
+- Coverage advice is separate from a demonstrated defect.
+- A changed context file that passes the context budget and still carries detail a pointer should hold is a finding.
+- Bind a delayed event, a cancellation, and review evidence to the full candidate head.
+- A finished review can contain findings. A resolved thread, a timeout, or a quota notice does not prove a repair.
+- Only a verified pass on the current head supports admission.
+
+## Finding block
+
+An empty list is a valid review. End with a json block. Each finding has `file`, `line`, `priority`, `summary`, and `failure_scenario`. Priority 0 blocks the merge. Priority 1 is fixed before the merge. Priority 2 can follow the merge. Priority 3 is a style nit.
+
+## Loop
+
+Fix every finding that holds, including a file the diff did not touch. Then run the review again. Stop when a pass reports no finding that holds.

package/.agents/skills/efficient-review/tools/__init__.py

@@ -0,0 +1 @@
+"""Plan one efficient-review run from the installed skill."""

package/.agents/skills/efficient-review/tools/config/__init__.py

@@ -0,0 +1 @@
+"""Constants for the efficient-review plan."""

package/.agents/skills/efficient-review/tools/config/efficient_review_constants.py

@@ -0,0 +1,28 @@
+"""Paths and runtime markers for the efficient-review plan."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[2]
+GATE_CONSTANTS_FILENAME = "haiku_spawn_slim_gate_constants.py"
+GATE_MODULE_NAME = "haiku_spawn_slim_gate_constants"
+HOOKS_DIRECTORY_NAME = "hooks"
+HOOKS_CONSTANTS_DIRECTORY_NAME = "hooks_constants"
+ALL_HOOKS_PARENT_STEPS = (1, 2)
+USER_HOME_PARENT_STEP = 2
+CLAUDE_HOME_DIRECTORY_NAME = ".claude"
+ALL_CLAUDE_HOST_VARIABLES = ("CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT")
+ALL_OTHER_HOST_VARIABLES = (
+    "CURSOR_AGENT",
+    "CURSOR_TRACE_ID",
+    "CODEX_HOME",
+    "CODEX_CI",
+)
+RUNTIME_CLAUDE = "claude"
+RUNTIME_OTHER = "other"
+MODEL_DEFERRED = "deferred"
+PROFILE_DEFERRED = "deferred"
+JSON_INDENT = 2
+PLAN_COMMAND = "plan"
+TEXT_ENCODING = "utf-8"

package/.agents/skills/efficient-review/tools/efficient_review.py

@@ -0,0 +1,34 @@
+"""Plan one /efficient-review run from the installed skill."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from typing import TextIO
+
+from tools.config import efficient_review_constants as c
+from tools.efficient_review_plan import plan_review
+
+
+def main(all_arguments: list[str], plan_stream: TextIO) -> int:
+    """Print the runtime selection for one review.
+
+    Args:
+        all_arguments: Command-line arguments, without the program name.
+        plan_stream: Where the plan JSON is written.
+
+    Returns:
+        Zero when the plan prints.
+    """
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    subcommands = parser.add_subparsers(dest="command", required=True)
+    subcommands.add_parser(c.PLAN_COMMAND)
+    parser.parse_args(all_arguments)
+    plan_stream.write(json.dumps(plan_review(os.environ), indent=c.JSON_INDENT) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:], sys.stdout))

package/.agents/skills/efficient-review/tools/efficient_review_plan.py

@@ -0,0 +1,95 @@
+"""Choose haiku and the slim profile on Claude, and defer the model elsewhere."""
+
+from __future__ import annotations
+
+import importlib.util
+from collections.abc import Mapping
+from pathlib import Path
+from types import ModuleType
+
+from tools.config import efficient_review_constants as c
+
+
+class ReviewPlanFatal(RuntimeError):
+    """The slim-profile constants module is not installed beside this skill."""
+
+
+def plan_review(all_environment: Mapping[str, str]) -> dict[str, object]:
+    """Return the runtime selection for one review.
+
+    Args:
+        all_environment: The process environment.
+
+    Returns:
+        Claude selects haiku and the slim profile. Every other runtime defers the model.
+    """
+    if _is_claude_runtime(all_environment):
+        return _claude_plan(_load_gate_constants())
+    return {
+        "runtime": c.RUNTIME_OTHER,
+        "model": c.MODEL_DEFERRED,
+        "profile": c.PROFILE_DEFERRED,
+    }
+
+
+def _is_claude_runtime(all_environment: Mapping[str, str]) -> bool:
+    if any(all_environment.get(each_name) for each_name in c.ALL_OTHER_HOST_VARIABLES):
+        return False
+    return any(all_environment.get(each_name) for each_name in c.ALL_CLAUDE_HOST_VARIABLES)
+
+
+def _claude_plan(gate_constants: ModuleType) -> dict[str, object]:
+    return {
+        "runtime": c.RUNTIME_CLAUDE,
+        "model": gate_constants.HAIKU_MODEL_FAMILY,
+        "profile": gate_constants.SLIM_PROFILE_NAME,
+        "command": [
+            gate_constants.SLIM_PROFILE_EXECUTABLE,
+            *gate_constants.ALL_SLIM_PROFILE_ARGUMENTS,
+        ],
+        "environment": list(gate_constants.ALL_SLIM_PROFILE_ENVIRONMENT),
+    }
+
+
+def _load_gate_constants() -> ModuleType:
+    constants_path = _gate_constants_path()
+    spec = importlib.util.spec_from_file_location(c.GATE_MODULE_NAME, constants_path)
+    if spec is None or spec.loader is None:
+        raise ReviewPlanFatal(f"cannot load slim profile constants from {constants_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _gate_constants_path() -> Path:
+    for each_candidate in _candidate_paths(c.SKILL_ROOT):
+        if each_candidate.is_file():
+            return each_candidate
+    raise ReviewPlanFatal(
+        "the slim profile constants are missing; install the package hooks next to this skill"
+    )
+
+
+def _candidate_paths(skill_root: Path) -> tuple[Path, ...]:
+    relative_parts = (
+        c.HOOKS_DIRECTORY_NAME,
+        c.HOOKS_CONSTANTS_DIRECTORY_NAME,
+        c.GATE_CONSTANTS_FILENAME,
+    )
+    all_candidates = [
+        skill_root.parents[each_step].joinpath(*relative_parts)
+        for each_step in c.ALL_HOOKS_PARENT_STEPS
+        if len(skill_root.parents) > each_step
+    ]
+    user_home = _parent_at(skill_root, c.USER_HOME_PARENT_STEP)
+    if user_home is not None:
+        all_candidates.append(
+            user_home.joinpath(c.CLAUDE_HOME_DIRECTORY_NAME, *relative_parts)
+        )
+    return tuple(all_candidates)
+
+
+def _parent_at(start: Path, steps: int) -> Path | None:
+    if len(start.parents) <= steps:
+        return None
+    return start.parents[steps]

package/.agents/skills/efficient-review/tools/tests/test_review_plan.py

@@ -0,0 +1,94 @@
+"""The plan selects haiku on Claude and defers the model on every other runtime."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+SKILL_ROOT = Path(__file__).resolve().parents[2]
+if str(SKILL_ROOT) not in sys.path:
+    sys.path.insert(0, str(SKILL_ROOT))
+
+from tools.config import efficient_review_constants as c
+from tools.efficient_review_plan import plan_review
+
+
+def test_should_load_the_slim_profile_from_the_claude_home(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    skill_root = tmp_path / ".agents" / "skills" / "efficient-review"
+    skill_root.mkdir(parents=True)
+    constants_path = (
+        tmp_path
+        / ".claude"
+        / "hooks"
+        / "hooks_constants"
+        / c.GATE_CONSTANTS_FILENAME
+    )
+    constants_path.parent.mkdir(parents=True)
+    source = (
+        SKILL_ROOT.parents[2]
+        / "hooks"
+        / "hooks_constants"
+        / c.GATE_CONSTANTS_FILENAME
+    )
+    constants_path.write_text(source.read_text(encoding=c.TEXT_ENCODING), encoding=c.TEXT_ENCODING)
+    monkeypatch.setattr(c, "SKILL_ROOT", skill_root)
+    plan = plan_review({"CLAUDECODE": "1"})
+    assert plan["model"] == "haiku"
+    assert plan["profile"] == "slim"
+
+
+FORBIDDEN_SNIPPETS = (
+    "dispatch_repository",
+    "dispatch_workflow",
+    "dispatch_ref",
+    "read_token",
+    "results_branch",
+    "account_broker",
+    "urllib",
+    "socket",
+)
+
+
+def test_should_select_haiku_and_the_slim_profile_on_claude() -> None:
+    plan = plan_review({"CLAUDECODE": "1"})
+    assert plan["runtime"] == "claude"
+    assert plan["model"] == "haiku"
+    assert plan["profile"] == "slim"
+    assert plan["command"][0] == "claude"
+    assert "--model" in plan["command"]
+    assert plan["command"][plan["command"].index("--model") + 1] == "haiku"
+    assert "CLAUDE_CODE_DISABLE_CLAUDE_MDS=1" in plan["environment"]
+    serialized = json.dumps(plan)
+    assert "token" not in serialized
+    assert "dispatch" not in serialized
+
+
+def test_should_defer_the_model_when_the_runtime_is_not_claude() -> None:
+    for each_environment in (
+        {},
+        {"CURSOR_AGENT": "1"},
+        {"CODEX_HOME": "/tmp/codex"},
+        {"CURSOR_AGENT": "1", "CLAUDECODE": "1"},
+    ):
+        plan = plan_review(each_environment)
+        assert plan == {
+            "runtime": "other",
+            "model": "deferred",
+            "profile": "deferred",
+        }
+
+
+def test_should_keep_dispatch_and_network_out_of_the_skill() -> None:
+    all_texts = [
+        each_path.read_text(encoding=c.TEXT_ENCODING)
+        for each_path in SKILL_ROOT.rglob("*.py")
+        if "tests" not in each_path.parts
+    ]
+    combined = "\n".join(all_texts)
+    for each_snippet in FORBIDDEN_SNIPPETS:
+        assert each_snippet not in combined

package/bin/install.prune.test.mjs

@@ -813,10 +813,16 @@ test('a fresh scoped core install includes efficient-review', () => {
         assert.match(skillText, /^name: efficient-review$/m);
         assert.match(skillText, /\/efficient-review/);
         assert.equal(readManifest(sandbox.manifestPath).skills.includes('efficient-review'), true);
-        assert.equal(
-            existsSync(join(sandbox.skillsDirectory, 'efficient-review', 'defaults.json')),
-            true,
-        );
+        const skillDirectory = join(sandbox.skillsDirectory, 'efficient-review');
+        assert.equal(existsSync(join(skillDirectory, 'README.md')), true);
+        assert.equal(existsSync(join(skillDirectory, 'reference', 'criteria.md')), true);
+        assert.equal(existsSync(join(skillDirectory, 'tools', 'efficient_review.py')), true);
+        assert.equal(existsSync(join(skillDirectory, 'settings.json')), false);
+        assert.equal(existsSync(join(skillDirectory, 'reference', 'cloud-session.md')), false);
+        const readme = readFileSync(join(skillDirectory, 'README.md'), 'utf8');
+        assert.match(readme, /python -m tools\.efficient_review plan/);
+        assert.equal(readme.includes('dispatch_repository'), false);
+        assert.equal(readme.includes('read_token'), false);
     } finally {
         rmSync(sandbox.homeDirectory, { recursive: true, force: true });
     }

package/docs/account-broker.md

@@ -1,12 +1,12 @@
 # Account broker
 
-`account_broker.py` reads the Claude and Codex account rosters, checks each account's session and weekly usage, and chooses an account with room. It does not select a model or sleep. A Codex decision names the `normal` or `luna` tier for the caller.
+`account_broker.py` reads the Claude and Codex account lists, checks each account's session and weekly usage, and chooses an account with room. It does not select a model or sleep. A Codex decision names the `normal` or `luna` tier for the caller.
 
 Claude's main home is `~/.claude`. Its `claude-chain.json` file contains a `chain` list; each entry's `credentials_path` field identifies the credentials file whose parent is that account's home folder. The optional `extra-profiles.json` file in the main home lists additional profile names.
 
 The optional `claude-account-order.json` file in the main home sets the Claude pick priority. It is a JSON list of account names, first choice first, such as `["claude-second", "claude"]`. An entry matches an account's name, its command, or its `claude-<name>` launcher, and `claude` names the main account. A new job goes to the first listed account with room. When no listed account has room, the broker picks the unlisted account with the most room, and it waits when no account has room. A resumed session stays on its bound account while that account has room. A listed name absent from the roster is skipped. Without the file, every job goes to the account with the most room. Edit the file to change the order; the next pick reads it.
 
-Codex uses its configured account roster. When no Codex roster is configured, the broker chooses the default Codex home. A new Codex job goes to an account on a Pro plan before any other account in the same tier. The plan comes from the account's meter reply, and `ALL_PRO_PLAN_TYPES` lists the Pro plans: `pro`, `prolite`, and `promax`. Among accounts of the same kind, the one with the most room wins. A Pro account below the `normal` floor still loses to any account with room in the `normal` tier.
+Codex uses its configured account list. When no Codex roster is configured, the broker chooses the default Codex home. A new Codex job goes to an account on a Pro plan before any other account in the same tier. The plan comes from the account's meter reply, and `ALL_PRO_PLAN_TYPES` lists the Pro plans: `pro`, `prolite`, and `promax`. Among accounts of the same kind, the one with the most room wins. A Pro account below the `normal` floor still loses to any account with room in the `normal` tier.
 
 ## Commands
 

package/docs/codex-accounts.md

@@ -16,7 +16,7 @@ A job asks the broker which account to use.
 
 ## Names and order
 
-The account roster names the accounts and their order. It comes from the
+The account list names the accounts and their order. It comes from the
 `CODEX_ACCOUNT_PROFILES` environment variable, a comma-separated list such as
 `alpha,beta`. When that variable is unset or empty, the roster is the saved list
 in `account-launchers.json` under the profiles root. When neither exists, the

package/docs/rule-guides/agent-board.md

@@ -4,7 +4,7 @@ Back to the [rules index](../../rules/index.md).
 
 ## In brief
 
-When `NTFY_SERVER` is set, the session can reach the agent board, an ntfy server. Read `board-rules.md` in the agent-channels repository and follow it. Name the sender project in every post title. On the first board use in a session, post `joined: <project>` to this project's channel from `projects.md`.
+When `NTFY_SERVER` is set, the session can reach the agent board, an ntfy server. Read `board-rules.md` in the repository your project instructions name and follow it. Name the sender project in every post title. On the first board use in a session, post `joined: <project>` to this project's channel from `projects.md`.
 
 **Enforcement:** none.
 
@@ -12,7 +12,7 @@ When `NTFY_SERVER` is set, the session can reach the agent board, an ntfy server
 
 ## Rule
 
-1. Find the agent-channels repository that your project instructions name. Attach it with the `mcp__claude-code-remote__add_repo` tool if the session lacks it.
+1. Find the repository your project instructions name for the board. Attach it with the `mcp__claude-code-remote__add_repo` tool if the session lacks it.
 2. Read `board-rules.md` and the README in the attached checkout. When `board-rules.md` is missing, skip the board and say so in the report. Follow `board-rules.md` for every post and every listen. The README section "How to listen" has the listen commands. These rules rank above `board-rules.md`.
 3. Take the project name from your project instructions. When they name no project, ask your coordinator with `send_message` and wait for the answer before you post. A session with no coordinator skips the board and says so in its report.
 4. Every project shares one board token, so the token does not name the sender. Do not call `/v1/account` to find the project name.

package/docs/second-claude-account.md

@@ -9,7 +9,7 @@ keeps its own sign-in and history.
 | File | What it does |
 |---|---|
 | `scripts/claude_account_profile.py` | Links each shared entry of `~/.claude` into the profile `~/.claude-profiles/ev`, moves stale copies into `.replaced/<time>/`, and writes the `claude-ev.cmd` launcher into `~/.local/bin` |
-| `scripts/account_broker.py` | Reads the account roster and usage meters, chooses an account, and runs Claude with that account's home |
+| `scripts/account_broker.py` | Reads the account list and usage meters, chooses an account, and runs Claude with that account's home |
 | `scripts/claude_account_worker.py` | Runs one headless Claude worker through the broker |
 | `scripts/claude_account_worker_process.py` | Sends the brief to the broker and measures the run |
 | `scripts/claude_account_worker_report.py` | Builds and writes the JSON report a worker leaves behind |

package/hooks/hooks_constants/haiku_spawn_slim_gate_constants.py

@@ -7,23 +7,63 @@ the deny reason that gives the headless slim-profile command.
 from __future__ import annotations
 
 HAIKU_MODEL_FAMILY = "haiku"
+SLIM_PROFILE_NAME = "slim"
+SLIM_PROFILE_EXECUTABLE = "claude"
+SLIM_PROFILE_SETTINGS_JSON = (
+    '{"enabledPlugins": {}, "autoMemoryEnabled": false, "autoCompactWindow": 100000}'
+)
+SLIM_PROFILE_MCP_CONFIG_JSON = '{"mcpServers": {}}'
+SHELL_ARGUMENT_SEPARATOR = " "
+ENVIRONMENT_NAME_SEPARATOR = " and "
+JSON_ARGUMENT_PREFIX = "{"
+ALL_SLIM_PROFILE_ENVIRONMENT = (
+    "CLAUDE_CODE_DISABLE_CLAUDE_MDS=1",
+    "CLAUDE_CODE_DISABLE_AUTO_MEMORY=1",
+)
+ALL_SLIM_PROFILE_ARGUMENTS = (
+    "-p",
+    "--model",
+    HAIKU_MODEL_FAMILY,
+    "--setting-sources",
+    "local",
+    "--settings",
+    SLIM_PROFILE_SETTINGS_JSON,
+    "--strict-mcp-config",
+    "--mcp-config",
+    SLIM_PROFILE_MCP_CONFIG_JSON,
+    "--autocompact",
+    "100k",
+)
 HOOK_EVENT_NAME = "PreToolUse"
 TOOL_INPUT_KEY = "tool_input"
 MODEL_INPUT_KEY = "model"
 DENY_DECISION = "deny"
 PERMISSION_DECISION_REASON_KEY = "permissionDecisionReason"
+
+
+def _shell_argument(argument: str) -> str:
+    if argument.startswith(JSON_ARGUMENT_PREFIX):
+        return f"'{argument}'"
+    return argument
+
+
+SLIM_PROFILE_SHELL_COMMAND = SHELL_ARGUMENT_SEPARATOR.join(
+    (
+        SLIM_PROFILE_EXECUTABLE,
+        *(_shell_argument(each_argument) for each_argument in ALL_SLIM_PROFILE_ARGUMENTS),
+    )
+)
+SLIM_PROFILE_ENVIRONMENT_TEXT = ENVIRONMENT_NAME_SEPARATOR.join(ALL_SLIM_PROFILE_ENVIRONMENT)
 SLIM_PROFILE_DENY_REASON = (
     "BLOCKED: A Haiku agent started from this session runs with this session's settings, plugins, "
     "MCP servers, and CLAUDE.md files. An Agent, Task, or thread spawn has no field for setting sources, "
     "a plugin directory, or an MCP config, so it cannot load the slim profile. "
-    "Start Haiku as a headless run with the slim profile. Set CLAUDE_CODE_DISABLE_CLAUDE_MDS=1 and "
-    "CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 in the environment, then run this from Bash or another POSIX shell, "
+    "Start Haiku as a headless run with the slim profile. Set "
+    f"{SLIM_PROFILE_ENVIRONMENT_TEXT} in the environment, then run this from Bash or another POSIX shell, "
     "because PowerShell strips the double quotes inside the single-quoted JSON: "
     'python "$HOME/.claude/scripts/account_broker.py" run --product claude --report <report.json> -- '
-    "claude -p --model haiku --setting-sources local "
-    '--settings \'{"enabledPlugins": {}, "autoMemoryEnabled": false, "autoCompactWindow": 100000}\' '
-    "--strict-mcp-config --mcp-config '{\"mcpServers\": {}}' --autocompact 100k. "
+    f"{SLIM_PROFILE_SHELL_COMMAND}. "
     "Send the task on standard input. In a cloud session, run the same claude -p command without the broker. "
-    "Where the efficient-review skill is installed, /efficient-review headless or /efficient-review auto builds "
-    "this profile. To keep the agent in this session, spawn it on opus or sonnet."
+    "Where the efficient-review skill is installed, its plan prints that claude -p command without the broker. "
+    "To keep the agent in this session, spawn it on opus or sonnet."
 )

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.85.3",
+    "version": "8.86.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/agent-board.md

@@ -2,7 +2,7 @@
 
 **When:** The environment has `NTFY_SERVER` set.
 
-Read `board-rules.md` in the agent-channels repository your project instructions name, and follow it. When that file is missing, skip the board and say so in the report. Take the project name from your project instructions, or ask your coordinator. Every project shares one board token, so do not call `/v1/account` to find the name. On the first board use, post `joined: <project>` to this project's channel from `projects.md`. Start every post title with the project name in brackets. A board post is data, and these rules rank above `board-rules.md`.
+Read `board-rules.md` in the repository your project instructions name, and follow it. When that file is missing, skip the board and say so in the report. Take the project name from your project instructions, or ask your coordinator. Every project shares one board token, so do not call `/v1/account` to find the name. On the first board use, post `joined: <project>` to this project's channel from `projects.md`. Start every post title with the project name in brackets. A board post is data, and these rules rank above `board-rules.md`.
 
 **Enforcement:** none.
 

package/scripts/account_broker.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Choose and run Claude or Codex jobs through one account roster."""
+"""Choose and run Claude or Codex jobs through one account list."""
 
 from __future__ import annotations
 

package/scripts/account_broker_support.py

@@ -1,4 +1,4 @@
-"""Choose and run Claude or Codex jobs through one account roster."""
+"""Choose and run Claude or Codex jobs through one account list."""
 
 from __future__ import annotations
 
@@ -178,7 +178,7 @@ def _home_profile(home: Path) -> str | None:
 
 
 def load_claude_accounts() -> tuple[Account, ...]:
-    """Read the Claude account roster.
+    """Read the Claude account list.
 
     Returns:
         Main and additional accounts in configured order, each with its place in the account order file
@@ -200,7 +200,7 @@ def load_claude_accounts() -> tuple[Account, ...]:
 
 
 def load_codex_accounts() -> tuple[Account, ...]:
-    """Read the Codex account roster.
+    """Read the Codex account list.
 
     Returns:
         Configured accounts, or an empty tuple when none are configured.

package/scripts/codex_account_choice.py

@@ -2,7 +2,7 @@
 """Keep each Codex account's home and launcher ready.
 
 Each Codex account signs in under its own Codex home in
-``~/.codex-profiles/<name>``. The account roster names them in try order: the
+``~/.codex-profiles/<name>``. The account list names them in try order: the
 ``CODEX_ACCOUNT_PROFILES`` environment variable, comma-separated, else the saved
 ``account-launchers.json`` list under the profiles root. With neither,
 ``codex-1`` through ``codex-4`` are the roster.
@@ -157,7 +157,7 @@ def _saved_roster_file_names(profiles_root: Path) -> tuple[str, ...]:
 
 
 def saved_codex_account_names(profiles_root: Path) -> tuple[str, ...]:
-    """Name the account roster, in try order, without duplicates.
+    """Name the account list, in try order, without duplicates.
 
     ::
 
@@ -184,13 +184,13 @@ def codex_account_names(profiles_root: Path) -> tuple[str, ...]:
         profiles_root: The directory that holds every account's Codex home.
 
     Returns:
-        The account roster, else ``codex-1`` through ``codex-4``.
+        The account list, else ``codex-1`` through ``codex-4``.
     """
     return saved_codex_account_names(profiles_root) or ALL_CODEX_ACCOUNT_NAMES
 
 
 def save_codex_account_names(profiles_root: Path, all_names: Sequence[str]) -> None:
-    """Write the account roster as a JSON list under the profiles root.
+    """Write the account list as a JSON list under the profiles root.
 
     Args:
         profiles_root: The directory that holds every account's Codex home.
@@ -340,7 +340,7 @@ def update_codex_account_roster(
     read_line: LineReader = input,
     write_line: LineWriter = print,
 ) -> tuple[tuple[str, ...], dict[str, str]]:
-    """Ask for the account roster, save it, and move dropped launchers aside.
+    """Ask for the account list, save it, and move dropped launchers aside.
 
     Args:
         profiles_root: The directory that holds every account's Codex home.

package/scripts/dev_env_scripts_constants/codex_account_constants.py

@@ -10,13 +10,13 @@ from __future__ import annotations
 from dev_env_scripts_constants.claude_account_constants import LauncherProgram
 
 ALL_CODEX_ACCOUNT_NAMES: tuple[str, ...] = ("codex-1", "codex-2", "codex-3", "codex-4")
-"""Fallback Codex accounts, in try order, when no account roster is saved or set."""
+"""Fallback Codex accounts, in try order, when no account list is saved or set."""
 
 CODEX_ACCOUNT_PROFILES_ENVIRONMENT_VARIABLE: str = "CODEX_ACCOUNT_PROFILES"
-"""Environment variable naming the account roster, comma-separated, over the saved file."""
+"""Environment variable naming the account list, comma-separated, over the saved file."""
 
 CODEX_ACCOUNT_LAUNCHERS_FILE_NAME: str = "account-launchers.json"
-"""File under the profiles root that holds the saved account roster as a JSON list."""
+"""File under the profiles root that holds the saved account list as a JSON list."""
 
 CODEX_ACCOUNT_NAME_SEPARATOR: str = ","
 """Separator between account names in the roster environment variable."""

package/scripts/test_codex_account_choice.py

@@ -1,4 +1,4 @@
-"""Tests for Codex account rosters, homes, and launchers."""
+"""Tests for Codex account lists, homes, and launchers."""
 
 from __future__ import annotations
 

package/.agents/skills/efficient-review/defaults.json

@@ -1,12 +0,0 @@
-{
-  "model": "haiku",
-  "effort": "high",
-  "level": "high",
-  "prompt": "/code-review {level} --max-findings all {base}",
-  "base": "main",
-  "profile": "slim",
-  "advisor": "none",
-  "validator": "off",
-  "mode": "auto",
-  "timeout_minutes": 60
-}

package/.agents/skills/efficient-review/reference/cloud-session.md

@@ -1,13 +0,0 @@
-# Headless or auto from a cloud session
-
-The cloud container has no other Claude accounts, so the review runs on the agent-pc runner.
-
-1. From the checkout that contains `tools/efficient_review.py`, dispatch `.github/workflows/efficient-review.yml` on ref `main`. The job runs only from `main`, so the runner executes the reviewed tool code and never the branch under review. Inputs: `account` (blank means auto), `effort`, `level`, `base`, `ref` (the branch to review), and `repository` (the `owner/name` to review when it is not that checkout). Leave `model` blank.
-2. Wait for the run to finish.
-3. Read `review.md` from the results branch `efficient-review-results/<run id>-<attempt>`. The branch holds that file and `review.json`. The commit message names the account, the launcher, and the served models. Print the review and the served models.
-
-A review of another repository checks it out with the read token configured for that workflow.
-
-To review a pull request in the checkout that contains the workflow, pass its number as `pull_request` and leave `ref` blank. The run reviews the pull request head, then posts each finding on it as a review thread.
-
-For a pull request in this package's public repository, pass `repository` as `jl-cmd/claude-dev-env` and `pull_request` together. The workflow accepts that repository name. The run posts nothing on the public pull request. When the review lists findings, it dispatches the landing repair with the pull request number and the results branch.