Agent skill

Tree

by skymanbp in skymanbp/cc-tree

Universal radial-tree exploration engine — loads a preset, grounds a root, expands every node through 12 framing passes, derives each child in 12 evidence-bearing fields, scores it, and recurses on…

MITAuto-check passedAgent Workflows

Install Tree

skills CLI
$ npx skills add skymanbp/cc-tree --skill tree -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install skymanbp/cc-tree tree --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/skymanbp/cc-tree.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/tree .claude/skills/tree && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
tree
GitHub stars
101
Token cost
~3.7k tokens
SKILL.md length
1,564 words
Files
1
Skills in repo
1
Repo updated
First seen
Licence
MIT

At a glance

Universal radial-tree exploration engine — loads a preset, grounds a root, expands every node through 12 framing passes, derives each child in 12 evidence-bearing fields, scores it, and recurses on…

  • Works in 5 steps: Invocation → Execution flow → Anti-patterns (see docs/ENGINE.md §9 for… → …
  • The user wants the engine itself — a custom preset via --preset <path
  • SKILL.md covers 1. Invocation, 2. Execution flow, 3. Anti-patterns (see… and 4. Output contract, plus 1 more section
  • Calls python

What it does

Tree is an agent skill from skymanbp/cc-tree. Universal radial-tree exploration engine — loads a preset, grounds a root, expands every node through 12 framing passes, derives each child in 12 evidence-bearing fields, scores it, and recurses on advances leaves until substantive convergence (or a user cap). Caps default to ∞; defer / TODO / NEEDS-MORE-INFO leaves are hard-banned. Use when the user wants the engine itself — a custom preset via --preset <path, explicit control of a run, or "tree of thoughts" / 穷尽的树状探索 in general; for the four shipped use-cases…

Its SKILL.md is about 3.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Agent Workflows, covering Brainstorming. The repository describes itself as: Claude Code plugin: universal radial-tree exploration engine. One tree skill + swappable presets (brainstorm / attack / design / code-audit) for divergent ideation, adversarial… The licence is MIT.

When your agent uses it

  • The user wants the engine itself — a custom preset via --preset <path
  • Explicit control of a run
  • Tree of thoughts / 穷尽的树状探索 in general
  • For the four shipped use-cases prefer /cc-tree:brainstorm

Example prompts

  • “tree of thoughts”
  • “/tree”

Requirements

  • Python 3

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Invocation
  2. Execution flow
  3. Anti-patterns (see docs/ENGINE.md §9 for the full list)
  4. Output contract
  5. References

What it can do on your machine

Read from SKILL.md and the folder at commit a780af1. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • python

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Tree loads about 3.7k tokens when it runs. Until then it costs about 168 tokens; SKILL.md has 1,564 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~168
When it runs · the whole SKILL.md, loaded when a task matches
~3.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from skymanbp/cc-tree at commit a780af1, republished under its MIT licence (© skymanbp). 1,564 words, ~3,732 tokens.

Download SKILL.mdSave it as .claude/skills/tree/SKILL.md (or your agent's skills folder).
name
tree
description
Universal radial-tree exploration engine — loads a preset, grounds a root, expands every node through 12 framing passes, derives each child in 12 evidence-bearing fields, scores it, and recurses on `advances` leaves until substantive convergence (or a user cap). Caps default to ∞; `defer / TODO / NEEDS-MORE-INFO` leaves are hard-banned. Use when the user wants the engine itself — a custom preset via `--preset <path>`, explicit control of a run, or "tree of thoughts" / 穷尽的树状探索 in general; for the four shipped use-cases prefer `/cc-tree:brainstorm`, `/cc-tree:attack`, `/cc-tree:design`, `/cc-tree:code-audit`, whose descriptions carry the per-use-case triggers.
disable-model-invocation
false
argument-hint
<root> --preset <name|path> [--lang <tag|auto>] [--width N|∞] [--depth N|∞] [--rounds N|conv] [--max-branches N|∞] [--out <dir>] [--glossary <path>] [--field…

tree — universal radial-tree exploration engine

What this skill is. A single engine implementing recursive radial-tree exploration (root → 12-framing expansion → per-node 12-field derivation → score → recurse on high-verdict leaves → terminate on substantive convergence). What varies between use-cases (brainstorm vs critique vs design vs code-audit) is the baseline recipe, node schema, scoring dimensions, and verdict vocabulary — all parameterized via a preset file.

What this skill is NOT. Not a one-shot LLM call that returns a bulleted list. Not a chat interface — once the §2.0 glossary grill has settled terminology and the root is written, the engine runs to convergence without further prompts (§F6). Not bundled with a model — pure prompt-engineering on top of Claude Code's existing model setting.

The full engine specification lives in docs/ENGINE.md. This SKILL.md is a 7-step navigation guide; Read docs/ENGINE.md before producing the first node (the engine spec is what defines "valid" for everything you'll write).


1. Invocation

/cc-tree:tree <root> --preset <name|path> [flags]

<root> is preset-typed:

  • brainstorm preset → topic string, e.g. "ways to detect dark-matter substructure"
  • attack preset → file path (.md / .tex / etc.) or quoted argument-text
  • design preset → design-prompt string or .md file path
  • code-audit preset → file path or directory path

--preset is required:

  • Built-in: brainstorm, attack, design, code-audit (resolve to presets/<name>.md in this plugin)
  • Path: ./my-custom.md (any .md file with the right frontmatter)
Common flags (apply across presets)
FlagDefaultMeaning
--lang <tag|auto>enOutput language for all localized prose (node statements, derivations, report narrative, warnings). Machine tokens — flag/command names, frontmatter & JSON keys, root_kind values, verdict labels, status tokens, filenames — always stay English. <tag> is a BCP-47-like code (en, zh, zh-Hans, zh-Hant, fr-CA); zh = Simplified Chinese, zh-Hant = Traditional. auto detects the dominant language of <root> and falls back to en for mixed / path-only / code-only input. Resolved once before preset load, recorded in run metadata (language_request / output_language / language_source), and never prompted mid-run. Full precedence, resume, and chain semantics: docs/ENGINE.md §1.0.
--width N∞Cap on final leaf count (the outer arc of the tree). ∞ / inf / unspecified all mean unlimited.
--depth N∞Cap on tree depth from root.
--rounds NconvCap on expansion rounds. conv = no cap; terminate by §6 substantive convergence.
--max-branches N∞Cap on new branches per node per round. Floor is 12 because §3 requires all 12 framings to fire; this flag only raises the ceiling.
--out <dir>tree-out/<UTCdate>__<slug>/Output directory. Per-preset commands override (e.g. brainstorm-out/).
--glossary <path>(preset-determined)Path to a glossary / FACTS.md / glossary section in a dossier; used by §2.0 grill prelude.
--field <name|path>(none)Field profile for domain-aware reviewer weighting. <name> → field-profiles/<name>.md in this plugin; <path> → a literal file. Feeds §3.C / §3.D / §3.I / §3.J + the §3.X / §4 evidence bar. Missing profile → warn + continue (non-blocking). See docs/ENGINE.md §2.2.
--seed-from <primary.md>(none)Seed the tree from a prior run's primary deliverable (shortlist.md / options.md / confirmed.md): each listed item enters as a depth-1 seed node and is re-expanded. The substrate for cross-preset chaining (docs/chaining.md). Alias: --from-prior.
--no-grilloffSkip §2.0 glossary grill prelude. Marks root-node terms as unverified; §6 convergence adds a warning.
--no-onlineoffDisable WebSearch / WebFetch. Local + already-Read references only.
--min-frameworks N12Minimum framing passes per node. Floor is 12 (full §3.A–§3.L); flag exists for documentation, not relaxation.
--min-novelty-ratio R0.15§6.1 condition 2 requires "last 2 rounds' high-verdict / total < R".

Presets and their command wrappers may document additional preset-specific flags (e.g. attack's --focus <section|claim|equation>); a flag documented by the active preset or its wrapper is not "unknown" (docs/ENGINE.md §1.3).

Caps default to ∞ on purpose. The intended termination is §6 substantive convergence — see docs/ENGINE.md §6. Caps are escape valves for quick exploration; when one trips, the engine still drives every in-flight node to a complete state before reporting WIDTH_CAP_REACHED / DEPTH_CAP_REACHED / ROUNDS_EXHAUSTED.


2. Execution flow

Required Reads at session start (before producing the first node):

  1. The preset file (presets/<name>.md or --preset <path>) — full file.
  2. docs/ENGINE.md — full file. This is the contract.
  3. docs/framings.md — the 12 framings with per-preset examples.
  4. If --glossary <path>: Read that glossary file in full.
Step 1 — Preset load

Open the preset file. Extract from its YAML frontmatter:

  • name, description, use-when (informational)
  • root_kind — topic | artifact | code | design-prompt
  • subject_label — what each tree node is called (idea, critique, option, finding, …)
  • verdict_enum — 4-tuple: advances / kept / pruned / blocked
  • convergence_metric — which verdict role counts toward the §6.1 condition-2 ratio. It must be one of the four verdict_enum role keys verbatim (advances / kept / pruned / blocked); alias spellings like novelty_ratio are rejected by the validator. All four shipped presets use advances (docs/presets.md)
  • score_dims — list of 5 scoring dimensions (key + name + desc)
  • node_schema — list of 12 node-field names
  • output_artifacts — file names for the per-verdict final reports

The preset body (below frontmatter) supplies:

  • §2 baseline recipe (what to Read / Grep / WebFetch to build the root)
  • Optional per-framing examples (§3.A–§3.L flavored for this preset)
  • Optional anti-pattern list specific to this preset
Step 2 — §2 baseline

Follow the preset's baseline recipe. For all presets this includes:

  • §2.0 (unless --no-grill): glossary-grill prelude. Lock root-node noun-phrases to the glossary if one was supplied; surface MISSING / AMBIGUOUS / CONFLICT one question at a time per docs/ENGINE.md §2.0.
  • §2.A or §2.B (preset-determined): build the root node from real evidence (Read files, Grep symbols, WebFetch references). The root must have the 5-8 fields the preset specifies, each with file:line or URL evidence.

Save the root to <out>/tree.md + <out>/tree.json before producing any framing branches.

Step 3 — §3 framing pass (12 passes per node)

For each node (starting with root, then any high-verdict leaf in the next round):

Run §3.A through §3.L, each producing at least 1 new child branch. See docs/framings.md for the full prompt per framing, including domain-specific examples per preset.

Parallelize when fan-out ≥ 5 (always true for the root and hot leaves): dispatch the 12 framings across Agent(Explore) sub-agents per the mandatory protocol in docs/ENGINE.md §8.1. Running them sequentially at that fan-out is a defect. Deep marginal leaves (< 5 expected children) may run sequentially.

§3.X (if --no-online is off): per node, do 1 round of WebSearch + WebFetch. The query set is preset-determined (brainstorm/design → prior art + tooling; attack → critiques / errata; code-audit → CVEs / advisories) — see docs/framings.md §3.X.

Show full SKILL.md (570 more words)Show less
Step 4 — §4 per-branch 12-field derivation

For each branch produced in §3, fill the preset's 12 node-field schema. Field requirements live in docs/ENGINE.md §4. Hard rules:

  • No field may contain 应该 / 大概 / probably / maybe / 也许 — the field is invalid and must be rewritten.
  • No field may contain defer / future work / TODO / FIXME / 略 / details omitted / 待定 / NEEDS-MORE-INFO-style placeholders — the node is forced to INCOMPLETE_FORBIDDEN and must be driven to completion before counting.
  • Numerical claims require a one-shot python (sympy/numpy) sanity check via Bash — output pasted into the field.
  • External references require WebFetch of the actual arXiv abs / DOI / spec page; WebSearch snippets are not sufficient.

Append the filled node to tree.md + tree.json immediately (incremental write — see §7 for crash-safety contract).

Step 5 — §5 scoring and verdict

Score the node along the preset's 5 dimensions (each 0–3, integer). Sum = score (max 15). Map score → verdict via the preset's verdict_enum and the preset-specific rule (e.g. brainstorm: score ≥ 11 ∧ no [NEEDS_VERIFICATION] → PROMISING; attack: score ≥ 11 ∧ artifact_defense empty → CONFIRMED).

Sibling merging (§5.4): any two siblings with cosine similarity ≥ 0.85 on their idea / critique / option / finding statement → merge, keep the higher-scored one, tag the other MERGED_INTO=<id>.

Step 6 — §6 convergence check

After every round, evaluate the 6 conditions in docs/ENGINE.md §6. All 6 must hold simultaneously to declare CONVERGED. If any user-specified --width / --depth / --rounds cap trips first, report the appropriate *_CAP_REACHED / ROUNDS_EXHAUSTED status, but all leaves must be complete before stopping.

If neither convergence nor a cap-trip, pick the highest-verdict leaf that hasn't been re-expanded yet, run §3–§5 on it, and loop.

Step 7 — §7 final report

When termination is declared, write the preset's output_artifacts to <out>/. For all presets this includes:

  • tree.md — full tree, human-readable
  • tree.json — full tree, machine-readable
  • The preset-specific primary deliverable (shortlist.md, confirmed.md, options.md, findings.md)
  • The preset-specific secondary deliverables (pending.md, marginal.md, refuted.md, …)

Then emit a terminal-report block per docs/ENGINE.md#74-final-report.


3. Anti-patterns (see docs/ENGINE.md §9 for the full list)

The five that most reliably degrade output quality:

  1. ❌ Pseudo-divergence. Two branches that differ only in word choice. Each branch must offer at least one of (a) a different testable prediction, (b) a different failure mode, (c) a different resource profile. Otherwise: merge.

  2. ❌ Defer-as-output. "This direction is promising but requires detailed analysis beyond scope." Forbidden by §F8. The engine must actually do the analysis (Read / WebFetch / Bash) or route to a sibling via §3.E constraint-variation.

  3. ❌ Cap-as-convergence. Declaring --width 20 reached → done. §6 convergence is the intended termination; caps are escape valves and trip ≠ converge.

  4. ❌ Skipping §3.K. "High-risk branches feel speculative, I'll focus on safe ones." §F4 + §3.K force ≥ 1 fully-explored high-risk branch per pass; absent it the pass is invalid.

  5. ❌ WebSearch snippet → conclusion. Snippets are search results, not source-of-truth. Every external citation requires WebFetch of the actual page; otherwise the field is invalid (rule 04 + rule 01 from cc-enforcer, if installed).


4. Output contract

<out>/
├── tree.md             # human-readable outline of every node
├── tree.json           # machine-readable, full 12 fields per node
├── glossary-anchors.md # §2.0 prelude output (unless --no-grill was set)
├── <primary>.md        # preset's "advances" / top-recommendation file
├── <secondary>.md*     # preset's "marginal / pending / refuted" files
├── <per-item>.md*      # preset-specific per-item detail files, when the
│                       #   preset's body declares them (design writes
│                       #   option_<id>.md, the design→attack chain handoff)
├── REPORT.md           # §7.4 final-report block (also echoed to stdout)
└── nodes/
    └── <id>.md         # spilled when a node's evidence > 100 lines

This is the same layout as docs/ENGINE.md §7.2; that section is authoritative if the two ever disagree.

Each node lands the moment its 12 fields are filled (§7.1 incremental write contract). Restart from interruption: just re-invoke the same /cc-tree:tree <root> --preset <name> --out <same-dir> — the engine detects the existing tree and resumes from the highest-id leaf.


5. References

© skymanbp, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/tree of skymanbp/cc-tree.

Open the folder on GitHubat commit a780af1

Compare with similar skills

Tree next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Tree compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Tree this skillskymanbp/cc-tree101—~3.7kAutomated safety check: PassMIT
Brainstormingxpinjection/test-driven-spring-boot11254 repos~2.6kAutomated safety check: PassMIT
LLM Councilgcpdev/llm-council-skill4611 repos~1kAutomated safety check: NotesMIT
Typesafe AIOpenAgentsInc/openagents4559 repos~2.5kAutomated safety check: PassMIT
Yao Meta Skillyaojingang/yao-meta-skill2.7k—~768Automated safety check: PassMIT
Trellis StartROYIANS/foliq-print-template-designer1356 repos~646Automated safety check: PassMIT

Similar skills

  • Brainstorming

    xpinjection/test-driven-spring-boot

    You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior.

    112 GitHub starsUsed in 54 repos~2.6k tokens
    Agent WorkflowsAuto-check passed
  • LLM Council

    gcpdev/llm-council-skill

    Multi-LLM collaborative brainstorming and planning. An agent skill from gcpdev/llm-council-skill.

    461 GitHub starsUsed in 1 repo~1k tokens
    Agent WorkflowsAuto-check: notes
  • Typesafe AI

    OpenAgentsInc/openagents

    Build AI-powered software with TypeSafe: small units of AI intelligence you can use like programming primitives.

    455 GitHub starsUsed in 9 repos~2.5k tokens
    Agent WorkflowsAuto-check passed
  • Yao Meta Skill

    yaojingang/yao-meta-skill

    Create, improve, or evaluate an existing skill from workflows, prompts, SOPs, scripts.

    2.7k GitHub stars~768 tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed
  • Trellis Start

    ROYIANS/foliq-print-template-designer

    Initializes an AI development session by reading workflow guides, developer identity, git status, active tasks, and project guidelines from .trellis/.

    135 GitHub starsUsed in 6 repos~646 tokens
    Agent WorkflowsAuto-check passed
  • Brainstorming Before Building

    jnMetaCode/superpowers-zh

    Turns a rough idea into an approved design before any code is written, sorting the request into spike, bounded or architectural and enforcing an approval gate.

    8.3k GitHub stars~1.8k tokensUpdated 3 days ago
    Agent WorkflowsAuto-check passed

Categories

Questions about Tree

What does Tree do?

Universal radial-tree exploration engine — loads a preset, grounds a root, expands every node through 12 framing passes, derives each child in 12 evidence-bearing fields, scores it, and recurses on…. Tree is an agent skill from skymanbp/cc-tree. Universal radial-tree exploration engine — loads a preset, grounds a root, expands every node through 12 framing passes, derives each child in 12 evidence-bearing fields, scores it, and recurses on advances leaves until substantive convergence (or a user cap).

When should I use Tree?

Tree fits situations like: the user wants the engine itself — a custom preset via --preset <path; explicit control of a run; tree of thoughts / 穷尽的树状探索 in general; for the four shipped use-cases prefer /cc-tree:brainstorm.

How do I install Tree in Claude Code?

Run `npx skills add skymanbp/cc-tree --skill tree -a claude-code`. Or copy the skill folder (skills/tree in skymanbp/cc-tree) into .claude/skills/tree in your project. Claude Code loads it when a task matches its description.

How do I install Tree in Codex?

Run `npx skills add skymanbp/cc-tree --skill tree -a codex`. Or copy the skill folder (skills/tree in skymanbp/cc-tree) into .agents/skills/tree in your project. Codex loads it when a task matches its description.

Can I use Tree in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add skymanbp/cc-tree --skill tree -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/tree, .gemini/skills/tree, .github/skills/tree and .opencode/skills/tree in your project.

What does Tree need to run?

Going by SKILL.md and its folder, Tree needs the command-line tools its instructions call (python). Our summary lists: Python 3.

Does Tree access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Tree safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Tree use?

Tree is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Tree use?

About 3.7k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Tree?

Skills that share tags, products or a category with Tree: Brainstorming (xpinjection/test-driven-spring-boot, 112 stars), LLM Council (gcpdev/llm-council-skill, 461 stars), Typesafe AI (OpenAgentsInc/openagents, 455 stars) and Yao Meta Skill (yaojingang/yao-meta-skill, 2.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Tree?

skymanbp (a GitHub user) maintains it in skymanbp/cc-tree, which has 101 GitHub stars. The repository was last updated on October 2, 2026.

Source: skymanbp/cc-tree on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.