@rse/ase 1.0.6 → 2.0.0

package/plugin/skills/ase-repo-review/SKILL.md

@@ -0,0 +1,406 @@
+---
+name: ase-repo-review
+argument-hint: "[--help|-h] [--severity|-S=(AUTO|LOW|MEDIUM|HIGH)] [--thorough|-t] [--staged] [--unstaged] [--branch|-b <branch>] [--commit|-c <commit>]"
+description: >
+    Perform a holistic, human-reviewer-style critique of the currently
+    staged Git changes (or, with `--unstaged`, of the unstaged and
+    untracked changes, with `--branch`, of a branch against its base,
+    or, with `--commit`, of a single commit) and emit an approve/reject verdict
+    with prioritized, severity-tagged, line-cited findings. Use when the
+    user wants the staged diff, a branch, or a commit "reviewed",
+    "critiqued", or "code-reviewed".
+user-invocable: true
+disable-model-invocation: false
+effort: high
+allowed-tools:
+    - "Bash(git diff *)"
+    - "Bash(git ls-files *)"
+    - "Bash(git rev-parse *)"
+    - "Bash(git for-each-ref *)"
+    - "Bash(git rev-list *)"
+    - "Bash(git merge-base *)"
+    - "Bash(git branch *)"
+    - "Bash(git worktree list *)"
+    - "Bash(git show *)"
+    - "Bash(git -C *)"
+    - "Agent"
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
+
+<purpose name="ase-repo-review">
+Review Changes
+</purpose>
+
+<expand name="getopt"
+    arg1="ase-repo-review"
+    arg2="--severity|-S=(AUTO|LOW|MEDIUM|HIGH) --thorough|-t --staged --unstaged --branch|-b= --commit|-c=">
+    $ARGUMENTS
+</expand>
+
+<objective>
+Review the currently staged (and/or unstaged) Git changes, the changes
+of a branch against its base, or a single commit the way an
+*experienced human reviewer* would - judging them *holistically* against
+the change's *own intent* and against *correctness*, *design fit*,
+*clarity*, *robustness*, *propagation*, freedom of *residue*, and
+*project-convention conformance* - and emit a single *approve /
+request-changes verdict* backed by *prioritized*, *severity-tagged*,
+*line-cited* findings. This is a *synthesizing critique*, not a mechanical
+scan: it complements `ase-code-lint` (mechanical quality), `ase-code-analyze`
+(logic/semantics), and `ase-repo-diff` (intent narrative and risk).
+</objective>
+
+Procedure
+---------
+
+<flow>
+
+1.  <step id="STEP 1: Determine Change Set">
+
+    1.  <if condition="<getopt-option-commit/> is not empty and (<getopt-option-branch/> is not empty or <getopt-option-staged/> is equal `true` or <getopt-option-unstaged/> is equal `true`)">
+        Only output the following <template/> and then *STOP* immediately:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-review**, ▶ ERROR: option `--commit` cannot be combined with `--branch`, `--staged`, or `--unstaged`
+        </template>
+        </if>
+
+        Set <changes/> to the *uncommitted* changes to review: to
+        `staged and unstaged` if both <getopt-option-staged/> and
+        <getopt-option-unstaged/> are equal `true`, to `staged` if only
+        <getopt-option-staged/> is equal `true`, to `unstaged` if only
+        <getopt-option-unstaged/> is equal `true`, and to empty otherwise.
+        Here, the `unstaged` changes always include the *untracked* files.
+
+    2.  <if condition="<getopt-option-branch/> is not empty">
+        Determine the *base* of the branch:
+
+        1.  Run the command
+            `git rev-parse --verify --quiet "<getopt-option-branch/>^{commit}"`.
+            If it fails, only output the following <template/> and then
+            *STOP* immediately:
+
+            <template>
+            ⧉ **ASE**: ✪ skill: **ase-repo-review**, ▶ ERROR: branch **<getopt-option-branch/>** does not exist
+            </template>
+
+        2.  Determine the *candidate base branches* by running the command
+            `git for-each-ref --format="%(refname:short)" refs/heads/`
+            (taken exactly as given), excluding <getopt-option-branch/>
+            itself. For each <candidate/>, run the command
+            `git rev-list --count "<candidate/>..<getopt-option-branch/>"`
+            to count the commits of the branch since its fork point from
+            <candidate/>, and *drop* every candidate with a count of `0`,
+            as it already contains the branch. Set <base/> to the
+            remaining candidate with the *smallest* count (the *nearest*
+            fork point); on a tie, prefer the checked-out branch (the
+            output of `git branch --show-current`), and then the first
+            candidate. If no candidate remains, only output the following
+            <template/> and then *STOP* immediately:
+
+            <template>
+            ⧉ **ASE**: ✪ skill: **ase-repo-review**, ▶ ERROR: no base branch determinable for branch **<getopt-option-branch/>**
+            </template>
+
+        3.  Run the command
+            `git merge-base "<base/>" "<getopt-option-branch/>"` and
+            capture its output into <base-commit/>.
+
+        4.  Only output the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ✪ skill: **ase-repo-review**, ⎇ branch: **<getopt-option-branch/>**, ⎇ base: **<base/>**
+            </template>
+
+        </if>
+        <elseif condition="<getopt-option-commit/> is not empty">
+        Run the command
+        `git rev-parse --verify --quiet "<getopt-option-commit/>^{commit}"`
+        and capture its output into <commit-id/>. If it fails, only output
+        the following <template/> and then *STOP* immediately:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-review**, ▶ ERROR: commit **<getopt-option-commit/>** does not exist
+        </template>
+        </elseif>
+
+    3.  Determine *whether there are changes at all* by running the
+        corresponding command(s) (taken exactly as given) and capturing
+        their combined output - the bare *list of changed file names* -
+        into <diff/>. This is a lightweight gate; the full diff is fetched
+        by the sub-agent in STEP 2, so capturing only the file-name list
+        here is sufficient:
+
+        <if condition="<getopt-option-branch/> is not empty and <changes/> is not empty">
+        Determine the *worktree* of the branch by running the command
+        `git worktree list --porcelain` and setting <worktree-dir/> to the
+        `worktree` path of the entry whose `branch` line is
+        `refs/heads/<getopt-option-branch/>` (or to empty if there is
+        none, as a branch not checked out anywhere carries no uncommitted
+        changes).
+
+        If <worktree-dir/> is not empty, set <scope>branch
+        <getopt-option-branch/> since base commit <base-commit/> plus the
+        <changes/> changes in worktree <worktree-dir/></scope> and run:
+
+        -   If <changes/> is equal `staged and unstaged`:
+
+            `git -C "<worktree-dir/>" diff --name-only "<base-commit/>"`
+
+            `git -C "<worktree-dir/>" ls-files --others --exclude-standard`
+
+        -   If <changes/> is equal `staged`:
+
+            `git -C "<worktree-dir/>" diff --cached --name-only "<base-commit/>"`
+
+        -   If <changes/> is equal `unstaged`:
+
+            `git diff --name-only "<base-commit/>..<getopt-option-branch/>"`
+
+            `git -C "<worktree-dir/>" diff --name-only`
+
+            `git -C "<worktree-dir/>" ls-files --others --exclude-standard`
+
+        From the output of the `ls-files` command, *skip* every listed
+        entry below the `.ase/` directory -- it carries *ASE*'s own
+        state, and hence is never part of the user's change set.
+
+        Otherwise, set <scope>branch <getopt-option-branch/> since base
+        commit <base-commit/></scope> and run:
+
+        `git diff --name-only "<base-commit/>..<getopt-option-branch/>"`
+        </if>
+        <elseif condition="<getopt-option-branch/> is not empty">
+        Set <scope>branch <getopt-option-branch/> since base commit
+        <base-commit/></scope> and run:
+
+        `git diff --name-only "<base-commit/>..<getopt-option-branch/>"`
+        </elseif>
+        <elseif condition="<getopt-option-commit/> is not empty">
+        Set <scope>commit <commit-id/></scope> and run:
+
+        `git show --format= --name-only --diff-merges=first-parent "<commit-id/>"`
+        </elseif>
+        <elseif condition="<changes/> is equal `staged and unstaged`">
+        Set <scope>staged and unstaged</scope> and run:
+
+        `git diff --name-only HEAD`
+
+        `git ls-files --others --exclude-standard`
+
+        From the output of the second command, *skip* every listed
+        entry below the `.ase/` directory -- it carries *ASE*'s own
+        state, and hence is never part of the user's change set.
+        </elseif>
+        <elseif condition="<changes/> is equal `unstaged`">
+        Set <scope>unstaged</scope> and run:
+
+        `git diff --name-only`
+
+        `git ls-files --others --exclude-standard`
+
+        From the output of the second command, *skip* every listed
+        entry below the `.ase/` directory -- it carries *ASE*'s own
+        state, and hence is never part of the user's change set.
+        </elseif>
+        <else>
+        Set <scope>staged</scope> and run:
+
+        `git diff --cached --name-only HEAD`
+        </else>
+
+    4.  <if condition="<diff/> is empty">
+        Only output the following <template/> and then *STOP* immediately:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-review**, ▶ status: **no changes to review**
+        </template>
+        </if>
+
+    </step>
+
+2.  <step id="STEP 2: Review Investigation">
+
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so
+    the user does *not* want the changes scrutinized or their
+    findings surfaced. *Skip* the entire review investigation: do
+    *not* invoke the `Agent` tool and do *not* read any change, set
+    <findings/> to the *empty* list, set <hidden/> to `0`, set
+    <verdict/> to `SKIPPED (boxing: black)`, set <summary/> to a
+    *one-line* neutral restatement of the change intent derived solely
+    from STEP 1, and proceed *directly* to STEP 3.
+
+    </if>
+
+    First, use the following <template/> to give a hint on this step:
+
+    <template>
+    <ase-tpl-bullet-secondary/> **REVIEW INVESTIGATION**
+    </template>
+
+    Dispatch the review investigation to a *sub-agent* via the `Agent`
+    tool so that *no* investigation details leak into the user-visible
+    transcript. The sub-agent performs the silent reading, the read-only
+    repository probing, and the critique; only its final structured return
+    value is consumed here.
+
+    Set <mode>thorough</mode> if <getopt-option-thorough/> is equal
+    `true`, and <mode>focused</mode> otherwise.
+
+    For this, invoke *exactly once* the tool:
+
+    ```text
+        Agent(
+            description:       "Review Investigation",
+            subagent_type:     "ase:ase-repo-review",
+            prompt:            "Review in <mode/> mode the changes of scope: <scope/>",
+            run_in_background: false
+        )
+    ```
+
+    Parse the single result message of the `Agent` tool as a JSON object,
+    set <summary/> to its `summary` field (a single crisp sentence
+    reconstructing the change's intent), and set <findings/> to its
+    `findings` field (a list).
+
+    Then *derive* the overall <verdict/> from <findings/>: set
+    <verdict/> to `REJECT - DEMANDS CHANGES` if *any* finding in
+    <findings/> has a `severity` field of `HIGH`; otherwise set
+    <verdict/> to `APPROVE`. The verdict is derived *before* the
+    severity floor below, so the floor only affects which findings are
+    *rendered*, never the verdict.
+
+    Then determine the *effective severity floor* <floor/> and its
+    origin <floor-origin/>: define the ordinal rank `LOW`=1, `MEDIUM`=2,
+    `HIGH`=3.
+
+    <if condition="<getopt-option-severity/> is equal `AUTO`">
+    Set <floor>MEDIUM</floor> and <floor-origin>boxing: grey</floor-origin>
+    if <ase-project-boxing/> is equal `grey` (grey boxing surfaces only
+    *material* findings of severity `MEDIUM` and above), and
+    <floor>LOW</floor> and <floor-origin>default</floor-origin> otherwise.
+    </if>
+    <else>
+    Set <floor><getopt-option-severity/></floor> and
+    <floor-origin>--severity <getopt-option-severity/></floor-origin>:
+    an *explicitly* given severity floor always *wins* over the boxing.
+    </else>
+
+    Then *apply the effective severity floor* <floor/>: *Keep* a finding
+    in <findings/> if and only if its `severity` field is `ACCEPTED` *or*
+    `rank(severity)` is greater than or equal to `rank(<floor/>)`;
+    *drop* all other findings, but set <hidden/> to the *number* of
+    dropped findings. With the floor `LOW`, all findings are kept.
+    `ACCEPTED` findings are *never* dropped. The floor affects only which
+    findings are *rendered*, never the <verdict/> derived above.
+
+    You *MUST* *NOT* output anything else in this STEP 2.
+
+    </step>
+
+3.  <step id="STEP 3: Verdict and Findings">
+
+    1.  Use the following <template/> to output the overall review in
+        <verdict/> and the reconstructed intent <summary/>:
+
+        <template>
+
+        <ase-tpl-bullet-signal/> **REVIEW VERDICT**: **<verdict/>**
+
+        <ase-tpl-bullet-normal/> **CHANGE INTENT**: <summary/>
+
+        </template>
+
+        You *MUST* *NOT* output anything else in this STEP 3.1.
+
+    2.  <if condition="<findings/> is empty">
+        Only output the following <template/> - with <note/> set to `the
+        change was not reviewed` if <verdict/> starts with `SKIPPED`, to
+        `no finding reaches severity <floor/>` if <hidden/> is greater
+        than `0`, and to `the change is clean` otherwise - and then
+        *SKIP* substep 3 of this STEP 3:
+
+        <template>
+
+        <ase-tpl-bullet-normal/> **NO FINDINGS**: <note/>, nothing to flag.
+
+        </template>
+        </if>
+
+    3.  <if condition="<findings/> is NOT empty">
+        Sort the findings by <severity/> from highest to lowest in the
+        fixed order `HIGH`, `MEDIUM`, `LOW`, `ACCEPTED`. Within the same
+        severity, keep the order returned by the sub-agent.
+
+        Then render a *three-column table* with one row per finding by
+        using the following output <template/>. For each finding, repeat
+        the third line, set <severity/> to its `severity` field, set
+        <dimension/> to its `dimension` field, set <location/> to its
+        `location` field, and set <finding/> to its `finding` field.
+
+        In the <location/> column, mark up the `file:line` reference
+        as code (with backticks) and prepend it with `▢ ` - keep the
+        sub-agent's own `:N` / `:N-M` line citation intact and do *not*
+        append any further line-count decoration.
+
+        Because the <finding/> text is free-form Markdown, *before*
+        emitting any row you *MUST* escape every literal `|` pipe
+        character inside <location/> and <finding/> as `\|` so it cannot
+        break the table column structure.
+
+        <template>
+        | Severity        | Dimension    | Finding                 |
+        | --------------- | ------------ | ----------------------- |
+        | **<severity/>** | <dimension/> | <location/>: <finding/> |
+        </template>
+
+        Keep the overall report *concise* and *brief*.
+        Do *not* output any further explanation.
+        </if>
+
+    4.  <if condition="<hidden/> is greater than `0`">
+        Output the following <template/>, so that suppressed findings
+        are never mistaken for a clean change:
+
+        <template>
+
+        <ase-tpl-bullet-normal/> **HIDDEN FINDINGS**: <hidden/> finding(s) below severity **<floor/>** suppressed (<floor-origin/>).
+
+        </template>
+        </if>
+
+    5.  Finally, give the closing hints by expanding the following
+        (which, depending on the configured <ase-guidance-level/>, may
+        expand into nothing and hence emit no output at all):
+
+        <if condition="<verdict/> starts with `REJECT`">
+        <ase-tpl-hint level="normal">
+        Use `/ase-task-edit` to derive a solution approach and plan for the findings which demand changes.
+        </ase-tpl-hint>
+        </if>
+
+        <if condition="<hidden/> is greater than `0`">
+        Set <rerun>/ase-repo-review -S LOW</rerun>, append ` --staged`
+        to <rerun/> if <getopt-option-staged/> is equal `true`, append
+        ` --unstaged` to <rerun/> if <getopt-option-unstaged/> is equal
+        `true`, append
+        ` -b <getopt-option-branch/>` to <rerun/> if
+        <getopt-option-branch/> is not empty, append
+        ` -c <getopt-option-commit/>` to <rerun/> if
+        <getopt-option-commit/> is not empty, and
+        append ` -t` to <rerun/> if <getopt-option-thorough/> is equal
+        `true`, so that the re-run reviews the same scope in the same mode.
+
+        <ase-tpl-hint level="normal">
+        Use `<rerun/>` to re-run the review with all findings shown (a fresh review, so its findings can differ).
+        </ase-tpl-hint>
+        </if>
+
+    </step>
+
+</flow>

package/plugin/skills/ase-repo-review/help.md

@@ -0,0 +1,181 @@
+
+##  NAME
+
+`ase-repo-review` - Review Changes
+
+##  SYNOPSIS
+
+`ase-repo-review`
+    [`--help`|`-h`]
+    [`--severity`|`-S`=(`AUTO`|`LOW`|`MEDIUM`|`HIGH`)]
+    [`--thorough`|`-t`]
+    [`--staged`]
+    [`--unstaged`]
+    [`--branch`|`-b` *branch*]
+    [`--commit`|`-c` *commit*]
+
+##  DESCRIPTION
+
+The `ase-repo-review` skill performs a *holistic*,
+*human-reviewer-style* critique of the *staged* Git changes (or, with
+`--unstaged`, of the *unstaged* and *untracked* changes, with both
+`--staged` and `--unstaged`, of *all* uncommitted changes, with
+`--branch`, of the changes of a *branch* against its *base*, or, with
+`--commit`, of a *single commit*) and emits a single
+*approve* / *reject* **verdict** backed by *prioritized*,
+*severity-tagged*, *line-cited* **findings**. Rather than scanning the
+code mechanically, it first *reconstructs the change's own intent* and
+then judges the diff *as a whole* against that intent - the way an
+experienced reviewer would on a pull request.
+
+The critique spans a fixed set of reviewer *dimensions*: **intent**
+(does the diff do what it set out to, without scope creep),
+**propagation** (the change fully and consistently carried over to call
+sites, types, schemas, registries, catalogs, and analogous sibling
+places, with matching contracts and terminology, and without orphans left
+behind), **coverage** (all special and edge cases handled, like empty
+values, boundaries, error paths, and all variants), **residue** (debug
+output, commented-out code, scaffolding, temporary files, build output,
+or secrets which do not belong into the change), **correctness**
+(latent bugs, broken control/data flow), **design** (fit with the surrounding architecture,
+naming, abstraction level), **clarity** (readability and
+self-documentation for a future reader), **robustness** (error handling,
+resource and concurrency safety), **security** and **performance** (risks
+introduced by the change), **convention** (conformance to the
+project's documented conventions - code style and the plan/spec
+formats described in `AGENTS.md` and the `ase-format-*` meta documents),
+**testing** (inadequate coverage for the change - new or fixed behavior
+left untested, adjacent tests not updated, or existing tests silently
+broken, disabled, or weakened), and **documentation** (user- or
+developer-facing docs - `README`, `CHANGELOG`, help text, or AI
+guidance/meta documents - left stale by the change).
+
+Each finding carries a *severity* - **HIGH**, **MEDIUM**, **LOW**, or
+**ACCEPTED** (a concern that is contractually addressed or accepted as a
+documented priority conflict) - and is *evidence-grounded*: it cites the
+exact `file:line` location it stems from. The overall verdict is
+**REJECT - DEMANDS CHANGES** when any *HIGH* finding remains, and
+**APPROVE** otherwise. The work is performed by a dedicated `ase-repo-review`
+sub-agent so that the silent reading and read-only repository probing
+never leak into the transcript; only the structured verdict and findings
+are rendered.
+
+The skill *complements* rather than duplicates its neighbors:
+`ase-code-lint` flags *mechanical* code-quality issues, `ase-code-analyze`
+inspects *logic and semantics*, `ase-repo-diff` narrates *what changed*
+(with optional coherence, risk, and blast-radius reports), and
+`ase-meta-diaboli` *adversarially challenges a thesis* - whereas
+`ase-repo-review` renders a *reviewer's judgment* on a concrete diff
+before it is committed or merged.
+
+##  OPTIONS
+
+-   `--severity`|`-S`=(`AUTO`|`LOW`|`MEDIUM`|`HIGH`):
+    Set the *severity floor* (default `AUTO`): findings below the chosen
+    threshold are suppressed, ordered `LOW` < `MEDIUM` < `HIGH`. The
+    default `AUTO` means `MEDIUM` for a project with `grey` boxing and
+    `LOW` (keep all findings) otherwise; an explicitly given floor always
+    wins over the boxing. `ACCEPTED` findings are never suppressed, and
+    the number of suppressed findings is always reported. Surviving
+    findings are rendered in *descending severity* order `HIGH`,
+    `MEDIUM`, `LOW`, `ACCEPTED`. The floor only affects the rendered
+    findings table, not the overall *verdict*, which is always derived
+    from all findings before the floor is applied.
+
+-   `--thorough`|`-t`:
+    Review *exhaustively* instead of reporting only a *few* high-signal
+    findings: report every well-grounded concern, including minor nits,
+    and additionally *plausible* concerns whose impact cannot be fully
+    proven, marked with "*Plausible:*" and rated at most `MEDIUM`.
+
+-   `--staged`:
+    Review the *staged* changes of the working copy. This is the default
+    if neither `--unstaged`, `--branch`, nor `--commit` is given.
+    Combined with `--unstaged`, review *all* uncommitted changes.
+    Combined with `--branch`, additionally review the staged changes of
+    the worktree where the *branch* is checked out.
+
+-   `--unstaged`:
+    Review the *unstaged* changes and the *untracked* files of the
+    working copy (except *ASE*'s own state below `.ase/`) instead of the
+    *staged* changes. Combined with `--staged`, review *all* uncommitted
+    changes. Combined with `--branch`, additionally review the unstaged
+    changes and untracked files of the worktree where the *branch* is
+    checked out.
+
+-   `--branch`|`-b` *branch*:
+    Review the commits of *branch* (any Git revision) since its fork
+    point from its *base*, instead of the *staged* changes. The base is
+    determined automatically as the local branch with the *nearest* fork
+    point (preferring the checked-out branch on a tie) and is reported
+    before the review. The commit messages are checked for mismatches
+    against the diff.
+
+-   `--commit`|`-c` *commit*:
+    Review the single *commit* (any Git revision) against its first
+    parent, instead of the *staged* changes. Its commit message is
+    checked for mismatches against the diff. This option cannot be
+    combined with `--branch`, `--staged`, or `--unstaged`.
+
+##  ARGUMENTS
+
+The `ase-repo-review` skill takes no positional arguments; it reviews the
+currently *staged* Git changes, with `--unstaged` the unstaged and
+untracked changes, with both `--staged` and `--unstaged` all uncommitted
+changes, with `--branch` a branch against its base, or with `--commit` a
+single commit.
+
+##  SCENARIOS
+
+-   You want the staged changes reviewed like a human reviewer would
+-   You want an approve or reject verdict before committing
+-   You want severity-tagged, line-cited findings on a diff
+-   You want a holistic judgment instead of a mechanical lint
+-   You want your not yet staged changes reviewed
+-   You want an exhaustive review of all uncommitted changes
+-   You want a feature branch reviewed before merging it
+-   You want a single, already committed change reviewed
+
+##  EXAMPLES
+
+Review the currently staged changes before committing:
+
+```text
+❯ /ase-repo-review
+```
+
+Review the staged changes, reporting only `MEDIUM` and `HIGH` findings:
+
+```text
+❯ /ase-repo-review -S MEDIUM
+```
+
+Review the unstaged and untracked changes only:
+
+```text
+❯ /ase-repo-review --unstaged
+```
+
+Review all uncommitted changes exhaustively, reporting all findings:
+
+```text
+❯ /ase-repo-review --staged --unstaged -t -S LOW
+```
+
+Review the branch `feature` against its base, including the uncommitted
+changes of its worktree:
+
+```text
+❯ /ase-repo-review -b feature --staged --unstaged
+```
+
+Review the last commit:
+
+```text
+❯ /ase-repo-review -c HEAD
+```
+
+##  SEE ALSO
+
+[`ase-repo-diff`](../ase-repo-diff/help.md), [`ase-repo-commit`](../ase-repo-commit/help.md), [`ase-code-lint`](../ase-code-lint/help.md), [`ase-code-analyze`](../ase-code-analyze/help.md),
+[`ase-meta-diaboli`](../ase-meta-diaboli/help.md).