claude-dev-env 8.85.3 → 8.87.0

package/.agents/skills/deepen/SKILL.md

@@ -2,35 +2,19 @@
 name: deepen
 description: >-
   Deepen a first user task before work starts. Triggers: /deepen, deepen this
-  task, first-task deepening, Cursor Cloud launch prompt.
+  task, first-task deepening, Cursor Cloud launch prompt. DeepStack intake
+  holds the contract.
 ---
 
 # deepen
 
-Rewrite a user task so the worker does the omitted expert job. Keep the rewrite short.
-
-## When this applies
-
-- An interactive first user task on Claude Code, Cursor, or Codex
-- `/deepen` with a task in the arguments
-- Cursor Cloud, where user `~/.cursor/hooks.json` does not run and `sessionStart` is deferred, so the launch prompt is already sent
+On a first task, `/deepen` plus a task, or a routine wake that has work, read DeepStack intake and follow it: [intake](https://github.com/jl-cmd-projects/DeepStack/blob/main/plugins/deepstack/skills/deepstack-mode/references/intake.md).
 
 Skip when the prompt already carries `CDE_DEEPEN:v1`, when the text is a thanks or yes/no or status line, when it is a slash command other than `/deepen`, when it is a `/loop` or helper report, or when it is a spawn rewrite that already starts with the poteto-mode prefix.
 
 A prompt that is only `/deepen` with no task is skipped. `/deepen` plus a task deepens the remainder.
 
-## Four answers
-
-1. What a top person in that field would do that this prompt omitted.
-2. The raw source to start from.
-3. The methods and tools they would use.
-4. What besides the agent or Jon would show the result is right.
-
-Then rewrite the user prompt to ask for exactly that job. Put `CDE_DEEPEN:v1` at the top.
-
-## How to deepen
-
-Read the task. Name the field. Fill the four answers from the checkout, the docs, and the tools already in the tree. Keep the rewrite shorter than a new spec. The worker should start from the raw source and finish at the proof.
+The deepening pass writes the worker prompt and stops. The worker runs that prompt.
 
 When you spawn a helper to fill the four answers, that helper's prompt starts with `CDE_DEEPEN_AGENT` so the first-task hook leaves it alone.
 
@@ -38,5 +22,5 @@ When you spawn a helper to fill the four answers, that helper's prompt starts wi
 
 - Claude desktop and CLI: a `prompt.submit` mod rewrites the visible text. The Python `UserPromptSubmit` hook is silent when that mod is on outside a cloud session.
 - Claude cloud and Codex local: the Python hook injects `additionalContext`. Command hooks cannot replace the prompt string.
-- Cursor Cloud: run this skill on the launch prompt.
+- Cursor Cloud: run DeepStack intake on the launch prompt. The host adapter for the three lines and the refusal lives with that host. This package keeps the gate.
 - Codex cloud orchestration skips command hooks. Local Codex only.

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/.agents/skills/search-before-acting/SKILL.md

@@ -2,8 +2,9 @@
 name: search-before-acting
 description: >-
   Search for what already does an ask before logging, planning, delegating,
-  or building it, then report what exists in four points and wait for the
-  user. Use when a user asks for new or changed behavior, a tool, a check,
+  or building it, then report what exists in four points. When the role-level
+  job is already authorized, continue that job. Use when a user asks for new
+  or changed behavior, a tool, a check,
   a workflow, a report, a tracker entry, or a plan, and before writing a
   brief for a worker.
 ---
@@ -17,7 +18,7 @@ The user should hear about work that already does their ask before anyone duplic
 1. Restate the ask as the outcome the user wants, in their words.
 2. Search every place in [`references/search-places.md`](references/search-places.md) that this session can reach. Note each place you could not reach.
 3. Sort each hit as full, partial, or related. A hit is full when it already produces the outcome from step 1.
-4. When any hit is full or partial, stop. Send the four-point report from [`references/report-shape.md`](references/report-shape.md) and wait for the user. When a hit is full, tell the user they already have it.
+4. When any hit is full or partial, send the four-point report from [`references/report-shape.md`](references/report-shape.md). When the role-level job is already authorized, continue that job. When it is not, wait for the user. When a hit is full, tell the user they already have it.
 5. When nothing is found, say where you looked in one line, then continue with the playbook below.
 
 ## Playbooks

package/.agents/skills/search-before-acting/playbooks/build.md

@@ -3,7 +3,7 @@
 Use this playbook before you build or change code, a hook, a skill, a rule, a workflow, or config for an ask.
 
 1. Run the skill steps. Search the places in [`../references/search-places.md`](../references/search-places.md), with production config and launcher options first when the ask names a running system.
-2. When a hit is full or partial, send the [report](../references/report-shape.md) and wait for the user's answer.
+2. When a hit is full or partial, send the [report](../references/report-shape.md). When the role-level job is already authorized, continue that job. When it is not, wait for the user's answer.
 3. When the user says go, build only the missing part from point 3 of the report. Extend the existing piece where it lives. Start a new piece only when the existing one cannot hold the addition, and say why in the pull request.
 4. When nothing exists, follow `prefer-existing-tools.md` to check open-source options, then build.
 5. Add an "Existing work" section to the pull request body. List each hit with its link or `file:line` and what the pull request adds on top of it. When nothing was found, say so and name the places searched. The pull request gate denies a body without this section.

package/.agents/skills/search-before-acting/playbooks/plan-or-log.md

@@ -4,6 +4,6 @@ Use this playbook before you add an ask to a tracker, open an issue or card for
 
 1. Run the skill steps. Search open and closed tracker entries for the ask first, then the rest of [`../references/search-places.md`](../references/search-places.md).
 2. When a tracker entry already names the ask, update that entry and link it. Skip the new entry.
-3. When code, config, or a merged pull request already does the ask in full or in part, send the [report](../references/report-shape.md) and wait for the user before you log or plan.
+3. When code, config, or a merged pull request already does the ask in full or in part, send the [report](../references/report-shape.md). When the role-level job is already authorized, continue that job. When it is not, wait for the user before you log or plan.
 4. When the user says go, log or plan only the missing part. Link each existing piece in the entry or plan, so the reader starts from what is live.
 5. When nothing exists, write the entry or plan with one line that names the places searched.

package/.agents/skills/search-before-acting/references/report-shape.md

@@ -1,6 +1,6 @@
 # Report shape
 
-Send this report when the search finds something that does the ask in full or in part. Send it before any log entry, plan, brief, or edit, and wait for the user.
+Send this report when the search finds something that does the ask in full or in part. Send it before any log entry, plan, brief, or edit. When the role-level job is already authorized, continue that job. When it is not, wait for the user.
 
 1. **What exists and where.** Each hit with a link or `file:line`, and whether it is live.
 2. **What it covers of the ask.** The parts of the outcome it already produces.

package/bin/codex-skill-load-block.mjs

@@ -11,10 +11,10 @@ export const DEEPEN_GUIDANCE_BLOCK_START = '<!-- claude-dev-env deepen: start --
 export const DEEPEN_GUIDANCE_BLOCK_END = '<!-- claude-dev-env deepen: end -->';
 export const DEEPEN_GUIDANCE_TEXT = [
     'Deepen the first interactive user task before any work starts.',
-    'Answer four things the prompt left out: what a top person in that field would do, the raw source to start from, the methods and tools they would use, and what besides the agent or Jon would show the result is right.',
-    'Then rewrite the task to ask for exactly that job. The rewrite carries the marker CDE_DEEPEN:v1.',
-    'On demand, follow the deepen skill or /deepen with a task.',
-    'Cursor Cloud has no user hooks.json and defers sessionStart, so the launch prompt is already sent. Use the deepen skill under ~/.cursor/skills there.',
+    'Follow DeepStack intake. Write SCOPE (role), EXAMPLES (illustration only), and ZOOM-IN BLOCKER before any plan.',
+    'The worker prompt carries the marker CDE_DEEPEN:v1 on line 1 and the SCOPE (role) line.',
+    'On demand, follow the DeepStack skill or /deepen with a task.',
+    'Cursor Cloud registers the DeepStack SessionStart hook and the first-task gate. Use DeepStack intake on the launch prompt.',
     'Codex cloud orchestration skips command hooks. This block is the local Codex instruction.',
 ].join('\n');
 

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/commands/deepen.md

@@ -1,5 +1,5 @@
 ---
-description: Deepen a task into the omitted expert job before work starts
+description: Deepen a task into the standing job before work starts
 argument-hint: [task to deepen]
 ---
 
@@ -7,13 +7,8 @@ Deepen this task before any work starts: `$ARGUMENTS`
 
 When `$ARGUMENTS` is empty, ask the user to paste the task and stop.
 
-When `$ARGUMENTS` holds a task, answer four things the prompt left out:
+When `$ARGUMENTS` holds a task, follow DeepStack intake at https://github.com/jl-cmd-projects/DeepStack/blob/main/plugins/deepstack/skills/deepstack-mode/references/intake.md.
 
-1. What a top person in that field would do that this prompt omitted.
-2. The raw source to start from.
-3. The methods and tools they would use.
-4. What besides the agent or Jon would show the result is right.
-
-Rewrite the task so it asks for exactly that job. Put `CDE_DEEPEN:v1` at the top of the rewrite. Then do only that job.
+Write `SCOPE (role):`, `EXAMPLES (illustration only):`, and `ZOOM-IN BLOCKER:` before any plan. Put `CDE_DEEPEN:v1` on line 1 of the worker prompt and carry the scope line there. The deepening pass writes that prompt and stops.
 
 Skip this command when the prompt already carries `CDE_DEEPEN:v1`.

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