claude-dev-env 2.14.0 → 2.15.0

package/scripts/sync_to_cursor/canonical_docs.py

@@ -3,7 +3,7 @@
 import shutil
 from pathlib import Path
 
-from sync_to_cursor.config import CANONICAL_DOC_FILES
+from sync_to_cursor.config import ALL_CANONICAL_DOC_FILES
 from sync_to_cursor.hashing import sha256_bytes
 
 
@@ -17,19 +17,19 @@ def sync_canonical_docs(
     if not dry_run:
         docs_out.mkdir(parents=True, exist_ok=True)
     new_docs: dict = {}
-    for name in CANONICAL_DOC_FILES:
-        src = claude / "docs" / name
-        dst = docs_out / name
+    for each_name in ALL_CANONICAL_DOC_FILES:
+        src = claude / "docs" / each_name
+        dst = docs_out / each_name
         if not src.is_file():
             if dst.is_file():
                 if not dry_run:
                     dst.unlink()
                 if not quiet:
-                    print(f"WARN     docs/{name} (source removed — deleted stale copy at {dst})")
+                    print(f"WARN     docs/{each_name} (source removed — deleted stale copy at {dst})")
             elif not quiet:
-                print(f"WARN     docs/{name} (missing source: {src})")
+                print(f"WARN     docs/{each_name} (missing source: {src})")
             continue
-        key = f"docs/{name}"
+        key = f"docs/{each_name}"
         src_hash = sha256_bytes(src.read_bytes())
         if dry_run:
             if dst.is_file():
@@ -44,10 +44,10 @@ def sync_canonical_docs(
 
 
 def check_canonical_docs(claude: Path, cursor: Path, docs_entries: dict) -> bool:
-    for name in CANONICAL_DOC_FILES:
-        key = f"docs/{name}"
-        src = claude / "docs" / name
-        dst = cursor / "docs" / name
+    for each_name in ALL_CANONICAL_DOC_FILES:
+        key = f"docs/{each_name}"
+        src = claude / "docs" / each_name
+        dst = cursor / "docs" / each_name
         if not src.is_file():
             if key in docs_entries:
                 return False

package/scripts/sync_to_cursor/config/__init__.py

@@ -0,0 +1,8 @@
+"""Shared configuration for the sync-to-cursor package."""
+
+GENERATOR_VERSION: str = "1.3.0"
+ALL_CANONICAL_DOC_FILES: tuple[str, ...] = ("CODE_RULES.md", "TEST_QUALITY.md")
+MAX_RULE_BODY_LINES: int = 50
+ALL_SKIPPED_RULE_FILE_NAMES: frozenset[str] = frozenset({"CLAUDE.md", "AGENTS.md"})
+MARKDOWN_SUFFIX: str = ".md"
+CLAUDE_RULES_DIRECTORY_NAME: str = "rules"

package/scripts/sync_to_cursor/engine.py

@@ -140,15 +140,40 @@ def _sync_rules(
     return summary, new_entries
 
 
+def _layout_from_args(args: argparse.Namespace) -> tuple[Path, Path, Path, Path]:
+    """Resolve Claude and Cursor roots from flags or the default layout.
+
+    Args:
+        args: Parsed CLI arguments.
+
+    Returns:
+        Claude root, Cursor root, rules output directory, and manifest path.
+
+    Raises:
+        SystemExit: When only one of `--claude-root` / `--cursor-root` is set.
+    """
+    claude_root = args.claude_root
+    cursor_root = args.cursor_root
+    if (claude_root is None) != (cursor_root is None):
+        raise SystemExit("both --claude-root and --cursor-root are required")
+    if claude_root is None:
+        return llm_layout_paths()
+    claude = Path(claude_root).expanduser().resolve()
+    cursor = Path(cursor_root).expanduser().resolve()
+    return claude, cursor, cursor / "rules", cursor / ".sync-manifest.json"
+
+
 def run(argv: list[str] | None = None) -> int:
     argument_parser = argparse.ArgumentParser(description="Sync Claude rules to Cursor .mdc files")
     argument_parser.add_argument("--force", action="store_true", help="Regenerate all outputs")
     argument_parser.add_argument("--dry-run", action="store_true", help="Print actions only")
     argument_parser.add_argument("--check", action="store_true", help="Exit 1 if anything stale")
     argument_parser.add_argument("--quiet", action="store_true", help="Minimal output when up to date")
+    argument_parser.add_argument("--claude-root", help="Claude layout root holding rules/ and docs/")
+    argument_parser.add_argument("--cursor-root", help="Cursor layout root receiving rules/ and docs/")
     args = argument_parser.parse_args(argv)
 
-    claude, cursor, out_dir, manifest_path = llm_layout_paths()
+    claude, cursor, out_dir, manifest_path = _layout_from_args(args)
     mappings = build_mappings(claude)
     old_manifest = _load_manifest(manifest_path)
     entries_meta: dict = old_manifest.get("entries", {})

package/scripts/sync_to_cursor/rules.py

@@ -7,7 +7,12 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal
 
-from sync_to_cursor.config import MAX_RULE_BODY_LINES
+from sync_to_cursor.config import (
+    ALL_SKIPPED_RULE_FILE_NAMES,
+    CLAUDE_RULES_DIRECTORY_NAME,
+    MARKDOWN_SUFFIX,
+    MAX_RULE_BODY_LINES,
+)
 
 
 def _parse_h2_sections(markdown: str) -> dict[str, str]:
@@ -412,6 +417,61 @@ def _path_scoped_mappings(rules_directory: Path, docs_directory: Path) -> tuple[
     )
 
 
+def _description_from_rule_file(rule_file: Path, fallback_key: str) -> str:
+    """Return the first markdown heading, or the rule key with spaces.
+
+    Args:
+        rule_file: Claude rule markdown to read.
+        fallback_key: Stem used when the file has no heading.
+
+    Returns:
+        A one-line Cursor `description` value.
+    """
+    for each_line in rule_file.read_text(encoding="utf-8").splitlines():
+        stripped = each_line.strip()
+        if stripped.startswith("# "):
+            return stripped[2:].strip()
+    return fallback_key.replace("-", " ")
+
+
+def _discovered_mappings(
+    rules_directory: Path, all_covered_source_names: set[str]
+) -> tuple[RuleMapping, ...]:
+    """Map remaining `*.md` rule files to `<stem>.mdc` Cursor rules.
+
+    Args:
+        rules_directory: Claude `rules/` directory.
+        all_covered_source_names: Rule filenames already claimed by curated mappings.
+
+    Returns:
+        One mapping per remaining markdown rule, sorted by filename.
+    """
+    if not rules_directory.is_dir():
+        return ()
+    all_discovered: list[RuleMapping] = []
+    for each_rule_file in sorted(rules_directory.glob("*.md")):
+        if each_rule_file.name in ALL_SKIPPED_RULE_FILE_NAMES:
+            continue
+        if each_rule_file.name in all_covered_source_names:
+            continue
+        key = each_rule_file.stem
+        paths_glob = _read_paths_glob(each_rule_file)
+        has_paths = paths_glob is not None
+        all_discovered.append(
+            RuleMapping(
+                key,
+                (each_rule_file,),
+                f"{key}.mdc",
+                not has_paths,
+                paths_glob,
+                _description_from_rule_file(each_rule_file, key),
+                "verbatim",
+                strip_leading_frontmatter=has_paths,
+            )
+        )
+    return tuple(all_discovered)
+
+
 def build_mappings(claude: Path) -> tuple[RuleMapping, ...]:
     """Resolve every rule into a concrete Cursor mapping against a Claude layout.
 
@@ -420,14 +480,25 @@ def build_mappings(claude: Path) -> tuple[RuleMapping, ...]:
 
     Returns:
         One RuleMapping per rule, each path-scoped rule carrying a glob derived
-        from its source rule's `paths:` frontmatter.
+        from its source rule's `paths:` frontmatter. Curated mappings come first,
+        then one generated mapping per remaining `rules/*.md` file.
     """
     rules_directory = claude / "rules"
     docs_directory = claude / "docs"
-    all_mappings = (
+    all_curated = (
         *_always_apply_mappings(rules_directory, docs_directory),
         *_path_scoped_mappings(rules_directory, docs_directory),
     )
-    mapping_by_key = {each_mapping.key: each_mapping for each_mapping in all_mappings}
+    mapping_by_key = {each_mapping.key: each_mapping for each_mapping in all_curated}
     assert set(mapping_by_key) == set(_merged_mapping_key_order)
-    return tuple(mapping_by_key[each_key] for each_key in _merged_mapping_key_order)
+    ordered_curated = tuple(mapping_by_key[each_key] for each_key in _merged_mapping_key_order)
+    all_covered_source_names = {
+        each_source.name
+        for each_mapping in ordered_curated
+        for each_source in each_mapping.sources
+        if each_source.suffix == MARKDOWN_SUFFIX
+        and each_source.parent.name == CLAUDE_RULES_DIRECTORY_NAME
+    }
+    return ordered_curated + _discovered_mappings(
+        rules_directory, all_covered_source_names
+    )

package/scripts/test_active_capability_references.py

@@ -32,7 +32,7 @@ def test_inventory_includes_shipped_skill_and_agent_names() -> None:
 
 def test_strip_inert_fenced_blocks_drops_historical_examples() -> None:
     markdown = (
-        "Use /commit for commits.\n"
+        "Use /sr-loop for cleanup.\n"
         "```historical\n"
         "Use /qbug for bugs.\n"
         "```\n"
@@ -40,7 +40,7 @@ def test_strip_inert_fenced_blocks_drops_historical_examples() -> None:
     )
     stripped = strip_inert_fenced_blocks(markdown)
     assert "/qbug" not in stripped
-    assert "/commit" in stripped
+    assert "/sr-loop" in stripped
 
 
 def test_extract_active_capability_names_finds_slash_and_backticks() -> None:

package/scripts/tests/AGENTS.md

@@ -10,6 +10,8 @@ pytest suite for the Python scripts and Pester suite for the PowerShell scripts
 | `test_setup_project_paths_config.py` | Configuration constants used by `setup_project_paths.py` |
 | `test_sweep_empty_dirs.py` | `sweep_empty_dirs.py` — age check, one-shot mode, and continuous-watch behavior |
 | `test_sync_to_cursor.py` | `sync_to_cursor/` package — mapping, hashing, manifest, and path resolution |
+| `test_rules.py` | Discovered Claude `rules/*.md` mappings to stem-named Cursor `.mdc` files |
+| `test_engine.py` | `sync_to_cursor` engine `--claude-root` / `--cursor-root` layout flags |
 | `test_grok_worker_constants.py` | `grok_worker_constants.py` — the accepted batch worker-key set stays in step with the worker key constants, and the unknown-key message names both its placeholders |
 
 ## PowerShell test files

package/scripts/tests/test_engine.py

@@ -0,0 +1,102 @@
+"""Tests for sync_to_cursor engine CLI roots."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent.parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from sync_to_cursor.engine import run as run_sync_to_cursor
+
+_CODE_STANDARDS_SECTION_ORDER = (
+    "COMMENT PRESERVATION",
+    "CORE PRINCIPLES",
+    "⚡ HOOK-ENFORCED RULES",
+    "3. REUSE CONSTANTS / 4. CONFIG LOCATIONS",
+    "5. NO ABBREVIATIONS",
+    "6. COMPLETE TYPE HINTS",
+    "9. SELF-CONTAINED COMPONENTS",
+)
+_TEST_QUALITY_SECTION_ORDER = (
+    "Delete Useless Tests",
+    "Test Dependencies MUST FAIL",
+    "Core Testing Principles",
+    "React Testing Patterns",
+    "Test File Organization",
+)
+
+
+def _write_minimal_curated_rules(rules_directory: Path) -> None:
+    rules_directory.mkdir(parents=True, exist_ok=True)
+    (rules_directory / "code-standards.md").write_text(
+        "# Code standards stub\n", encoding="utf-8"
+    )
+    (rules_directory / "tasklings-preferences.md").write_text(
+        '---\npaths:\n  - "Y:/x/**"\n---\n\n# Tasklings\n',
+        encoding="utf-8",
+    )
+    (rules_directory / "bdd.md").write_text("# BDD\n", encoding="utf-8")
+    (rules_directory / "testing.md").write_text(
+        '---\npaths:\n  - "**/test_*.py"\n---\n\n# Testing\n',
+        encoding="utf-8",
+    )
+    (rules_directory / "research-mode.md").write_text("# RM\n", encoding="utf-8")
+    (rules_directory / "conservative-action.md").write_text("# CA\n", encoding="utf-8")
+    (rules_directory / "explore-thoroughly.md").write_text("# ET\n", encoding="utf-8")
+
+
+def _write_minimal_docs(docs_directory: Path) -> None:
+    docs_directory.mkdir(parents=True, exist_ok=True)
+    (docs_directory / "CODE_RULES.md").write_text(
+        "\n\n".join(f"## {title}\n\nalpha" for title in _CODE_STANDARDS_SECTION_ORDER)
+        + "\n",
+        encoding="utf-8",
+    )
+    (docs_directory / "TEST_QUALITY.md").write_text(
+        "\n\n".join(f"## {title}\n\nbeta" for title in _TEST_QUALITY_SECTION_ORDER)
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def test_explicit_roots_write_stem_named_mdc(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    claude = tmp_path / "claude-home"
+    cursor = tmp_path / "cursor-home"
+    _write_minimal_curated_rules(claude / "rules")
+    _write_minimal_docs(claude / "docs")
+    (claude / "rules" / "plain-language.md").write_text(
+        "# Plain language\n\nUse short sentences.\n",
+        encoding="utf-8",
+    )
+    (claude / "rules" / "CLAUDE.md").write_text("# Inventory\n", encoding="utf-8")
+    monkeypatch.delenv("LLM_SETTINGS_ROOT", raising=False)
+    assert cursor.exists() is False
+    assert (
+        run_sync_to_cursor(
+            [
+                "--force",
+                "--claude-root",
+                str(claude),
+                "--cursor-root",
+                str(cursor),
+            ]
+        )
+        == 0
+    )
+    generated = (cursor / "rules" / "plain-language.mdc").read_text(encoding="utf-8")
+    assert 'description: "Plain language"' in generated
+    assert "alwaysApply: true" in generated
+    assert "Use short sentences." in generated
+    assert not (cursor / "rules" / "CLAUDE.mdc").is_file()
+
+
+def test_explicit_roots_require_both_flags(tmp_path: Path) -> None:
+    with pytest.raises(SystemExit):
+        run_sync_to_cursor(["--force", "--claude-root", str(tmp_path)])

package/scripts/tests/test_rules.py

@@ -0,0 +1,79 @@
+"""Tests for discovered Claude-to-Cursor rule mappings."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent.parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from sync_to_cursor.rules import build_mappings
+
+_PACKAGE_ROOT = _SCRIPTS_DIR.parent
+_SKIPPED_RULE_FILE_NAMES = frozenset({"CLAUDE.md", "AGENTS.md"})
+
+
+def _write_minimal_curated_rules(rules_directory: Path) -> None:
+    rules_directory.mkdir(parents=True, exist_ok=True)
+    (rules_directory / "code-standards.md").write_text(
+        "# Code standards stub\n", encoding="utf-8"
+    )
+    (rules_directory / "tasklings-preferences.md").write_text(
+        '---\npaths:\n  - "Y:/x/**"\n---\n\n# Tasklings\n',
+        encoding="utf-8",
+    )
+    (rules_directory / "bdd.md").write_text("# BDD\n", encoding="utf-8")
+    (rules_directory / "testing.md").write_text(
+        '---\npaths:\n  - "**/test_*.py"\n---\n\n# Testing\n',
+        encoding="utf-8",
+    )
+    (rules_directory / "research-mode.md").write_text("# RM\n", encoding="utf-8")
+    (rules_directory / "conservative-action.md").write_text("# CA\n", encoding="utf-8")
+    (rules_directory / "explore-thoroughly.md").write_text("# ET\n", encoding="utf-8")
+
+
+def test_build_mappings_emits_stem_mdc_for_remaining_claude_rules(
+    tmp_path: Path,
+) -> None:
+    claude = tmp_path / ".claude"
+    _write_minimal_curated_rules(claude / "rules")
+    (claude / "docs").mkdir(parents=True, exist_ok=True)
+    (claude / "rules" / "plain-language.md").write_text(
+        "# Plain language\n\nBe brief.\n",
+        encoding="utf-8",
+    )
+    (claude / "rules" / "CLAUDE.md").write_text(
+        "# Package inventory\n", encoding="utf-8"
+    )
+    (claude / "rules" / "AGENTS.md").write_text("# Agent inventory\n", encoding="utf-8")
+    mappings = build_mappings(claude)
+    output_by_key = {each_mapping.key: each_mapping for each_mapping in mappings}
+    discovered = output_by_key["plain-language"]
+    assert discovered.output_name == "plain-language.mdc"
+    assert discovered.always_apply is True
+    assert discovered.description == "Plain language"
+    assert "CLAUDE.md" not in {
+        each_source.name
+        for each_mapping in mappings
+        for each_source in each_mapping.sources
+    }
+    assert "AGENTS.md" not in {
+        each_source.name
+        for each_mapping in mappings
+        for each_source in each_mapping.sources
+    }
+
+
+def test_every_shipped_claude_rule_maps_to_an_mdc() -> None:
+    mappings = build_mappings(_PACKAGE_ROOT)
+    output_name_by_rule_file = {}
+    for each_mapping in mappings:
+        for each_source in each_mapping.sources:
+            if each_source.parent.name == "rules" and each_source.suffix == ".md":
+                output_name_by_rule_file[each_source.name] = each_mapping.output_name
+    for each_rule_file in sorted((_PACKAGE_ROOT / "rules").glob("*.md")):
+        if each_rule_file.name in _SKIPPED_RULE_FILE_NAMES:
+            continue
+        assert each_rule_file.name in output_name_by_rule_file, each_rule_file.name

package/skills/anthropic-plan/AGENTS.md

@@ -1,6 +1,6 @@
 # anthropic-plan
 
-**Trigger:** `/anthropic-plan`, `/plan`, "plan this first", "think before coding", "make a plan", "scope this out", "don't code yet", and non-trivial requests that need source-grounded design before build work.
+**Trigger:** `/anthropic-plan`, "plan this first", "think before coding", "make a plan", "scope this out", "don't code yet", and non-trivial requests that need source-grounded design before build work.
 
 Creates a repo-local plan packet under `docs/plans/<slug>/` by running the `plan-packet.mjs` workflow. The skill first drafts a short starting plan and gets the user's approval in plan mode (`EnterPlanMode` / `ExitPlanMode`); on approval it runs the workflow. The packet holds context, spec, implementation steps, validation, and a handoff prompt for the build agent. The skill stops before any production code changes.
 

package/skills/anthropic-plan/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: anthropic-plan
-description: Workflow-backed implementation planning that creates a deep repo-local packet under docs/plans/<slug>/ before any code changes. Use for /anthropic-plan, /plan, "plan this first", "think before coding", "make a plan", "scope this out", "don't code yet", and non-trivial implementation requests that need source-grounded design, TDD steps, and validator approval before build work.
+description: Workflow-backed implementation planning that creates a deep repo-local packet under docs/plans/<slug>/ before any code changes. Use for /anthropic-plan, "plan this first", "think before coding", "make a plan", "scope this out", "don't code yet", and non-trivial implementation requests that need source-grounded design, TDD steps, and validator approval before build work.
 ---
 
 # Anthropic Plan

package/skills/anthropic-plan/test_skill_contract.py

@@ -9,6 +9,7 @@ SKILL_DIRECTORY = Path(__file__).resolve().parent
 CLAUDE_DIRECTORY = SKILL_DIRECTORY.parent.parent
 SKILL_PATH = SKILL_DIRECTORY / "SKILL.md"
 PLAN_COMMAND_PATH = CLAUDE_DIRECTORY / "commands" / "plan.md"
+SR_LOOP_COMMAND_PATH = CLAUDE_DIRECTORY / "commands" / "sr-loop.md"
 VALIDATOR_AGENT_PATH = CLAUDE_DIRECTORY / "agents" / "plan-packet-validator.md"
 
 
@@ -57,13 +58,14 @@ def test_skill_names_validator_and_stop_before_code_rules() -> None:
     assert "stop before implementation" in skill_text.lower()
 
 
-def test_plan_command_routes_to_anthropic_plan_without_stale_skills() -> None:
-    command_text = PLAN_COMMAND_PATH.read_text(encoding="utf-8")
+def test_skill_keeps_anthropic_plan_slash_without_plan_command() -> None:
+    skill_text = SKILL_PATH.read_text(encoding="utf-8")
 
-    assert "anthropic-plan" in command_text
-    assert "write-plan" not in command_text
-    assert "review-plan" not in command_text
-    assert "plan-executor" not in command_text
+    assert "/anthropic-plan" in skill_text
+    assert not PLAN_COMMAND_PATH.exists()
+    assert SR_LOOP_COMMAND_PATH.exists()
+    assert "write-plan" not in skill_text
+    assert "plan-executor" not in skill_text
 
 
 def test_validator_agent_exists_and_is_read_only() -> None:

package/skills/prototype/SKILL.md

@@ -45,7 +45,7 @@ Follow `workflows/sandbox.md`. In short:
 
 ### Phase 2 — Promotion
 
-Run only in the normal, fully-hooked session — never inside the sandbox. Follow `workflows/promotion.md`, which drives the clean-room task seeds in `reference/promotion-tasks.md`: fresh branch off live `origin/main`, POC content as an uncommitted diff, cleanup and privacy sweep, review and verification under the [review guide](../reviews/SKILL.md#review-workflow), then `/commit` and a draft PR handed to a PR-loop skill. State the two honest limitations from `reference/honest-limitations.md`.
+Run only in the normal, fully-hooked session — never inside the sandbox. Follow `workflows/promotion.md`, which drives the clean-room task seeds in `reference/promotion-tasks.md`: fresh branch off live `origin/main`, POC content as an uncommitted diff, cleanup and privacy sweep, review and verification under the [review guide](../reviews/SKILL.md#review-workflow), then commit by hand per `git-workflow` and a draft PR handed to a PR-loop skill. State the two honest limitations from `reference/honest-limitations.md`.
 
 ## Task seeding
 
@@ -58,7 +58,6 @@ At the start of Phase 2, register every item in `reference/promotion-tasks.md` a
 | `fresh-branch` | Sandbox step 1; Promotion step 2 | isolated worktree JSON (`worktree_path`, `base_commit`, `repo_root`) | Refuse — see refusal cases |
 | `privacy-hygiene` | Promotion step 5 | personal-data and secret sweep of the diff | Warn; do a manual review before continuing |
 | [Review guide](../reviews/SKILL.md#review-workflow) | Promotion step 6 | review and verification of the real diff | Stop and report the incomplete promotion |
-| `/commit` (command) | Promotion step 7 | conventional commit + push | Commit and push by hand per `git-workflow` |
 | `autoconverge` (default; `pr-converge` or `bugteam` as alternatives) | Promotion step 9 | the PR converged to ready | Stop after the draft PR; tell the user to converge manually |
 
 ## Degree of freedom

package/skills/prototype/reference/promotion-tasks.md

@@ -16,7 +16,7 @@ Promotion runs in the **normal, fully-hooked session** — never inside the `--b
 
 6. **Review and verify the real diff.** Apply the [review guide](../../reviews/SKILL.md#review-workflow). Evidence: the checks run and each required finding repaired. Do not rely on sandbox testing as promotion evidence.
 
-7. **Commit and open a draft PR.** After the review and verification record is complete, run `/commit`, then open a draft PR per the `git-workflow` rule. Evidence: the commit hash and the PR URL.
+7. **Commit and open a draft PR.** After the review and verification record is complete, commit by hand per the `git-workflow` rule, then open a draft PR. Evidence: the commit hash and the PR URL.
 
 8. **State the honest limitations.** Post the two statements from `reference/honest-limitations.md` — write-time rules never ran; TDD ordering waived — in the PR body or to the user. Evidence: the text was included.
 

package/skills/prototype/workflows/promotion.md

@@ -16,7 +16,7 @@ The task seeds carry the full ordered detail. The shape:
 4. **Cleanup.** Remove scratch files, debug dumps, and temp helpers the POC created (`cleanup-temp-files` rule).
 5. **Privacy sweep** via `privacy-hygiene` over the diff.
 6. **Review and verify** the real diff against the [review guide](../../reviews/SKILL.md#review-workflow). Record the checks run and repair every required finding.
-7. **Commit and PR.** After the review and verification record is complete, run `/commit`, then open a draft PR per the `git-workflow` rule.
+7. **Commit and PR.** After the review and verification record is complete, commit by hand per the `git-workflow` rule, then open a draft PR.
 8. **State the honest limitations** from `reference/honest-limitations.md` in the PR body or to the user.
 9. **Converge** by handing the PR to `autoconverge` by default; use `pr-converge` for paced ticks or `bugteam` for an open-loop audit.
 

package/agents/caveman.md

@@ -1,73 +0,0 @@
----
-name: caveman
-description: Trims noise from an artifact the main caller has already authored. Input is a draft (skill, doc, plan, response, README, prompt, PR description) — output is the same artifact with filler, hedging, preamble, recap, and restatement removed. Preserves structure, technical substance, frontmatter, and anything load-bearing. Does NOT redesign, restructure, or overrule the caller's scope decisions.
-color: red
----
-
-You are the caveman. You trim. You do not build. You do not restructure.
-
-## What you are
-
-A noise filter. The main caller has already decided *what* the artifact is, *how* it is structured, and *what lives in it*. Your job is to strip fluff off that artifact without touching the bones.
-
-You are downstream of design decisions, not upstream.
-
-## What you trim
-
-| Noise type | Example |
-|---|---|
-| Preamble / recap | "As discussed above, this skill will..." |
-| Hedging | "This might, in some cases, potentially..." |
-| Filler transitions | "Now, moving on to..." / "It's worth noting that..." |
-| Restatement | the same point made twice in different words |
-| Empty future-proofing | parameters, sections, or fields with no current consumer |
-| Dead examples | examples that duplicate another example without adding coverage |
-| Pleasantries | "Hope this helps." / "Feel free to..." |
-| Vague qualifiers | "various", "several", "a number of" — replace with the actual count or cut |
-
-Rewrite prose into the caveman pattern only where it does not change meaning: `[thing] [action] [reason]. [next step].`
-
-## What you do NOT touch
-
-- **Structure the caller chose.** Four sections in, four sections out. Do not collapse or merge.
-- **Frontmatter fields.** All fields stay. Tighten values if verbose; do not drop fields.
-- **Technical substance.** Code, commands, paths, URLs, errors, JSON, schema — unchanged.
-- **Trigger words / activation phrases.** Load-bearing for skill matching.
-- **Safety / escape-hatch language.** Warnings about destructive ops, irreversible actions, credentials, money, production systems — preserve verbatim.
-- **Caller-flagged content.** If the caller said "keep X verbatim", X is untouchable.
-- **Counts and specifics.** Numbers, thresholds, version strings, identifiers — unchanged.
-- **Register in examples and docstrings.** Unless caller asked for caveman voice throughout, keep the original register of user-facing copy.
-
-## What you do NOT decide
-
-You do not tell the caller:
-- "Use the existing tool instead" — design call, caller's call.
-- "Make this one file instead of three" — structure call, caller's call.
-- "Drop this section" — scope call, caller's call.
-- "Add tests" / "remove tests" — scope call, caller's call.
-
-If you suspect a section is pure noise, flag it in the report. Leave it in place unless the caller told you to remove it.
-
-## Process
-
-1. Read the artifact end to end before touching it.
-2. Mark the bones — frontmatter, structure, technical substance, trigger words, safety language. Off-limits.
-3. Trim noise per the table above.
-4. Return the trimmed artifact in the caller's original file format.
-
-## Output shape
-
-```
-trimmed: <path or artifact name>
-removed: <bullets — noise categories cut, with rough line counts>
-preserved-verbatim: <what you refused to touch and why>
-flagged: <content you suspect is noise but left in place for caller to decide>
-```
-
-No recap of the artifact itself. Caller has it.
-
-## Escape hatch
-
-If trimming would drop a safety warning, remove an irreversible-action caveat, collapse a distinction the caller made deliberately, or if you are unsure whether content is load-bearing — leave it in place and flag it. Ask before cutting.
-
-Terse is for noise, not for substance.