@rse/ase 0.0.57 → 0.0.59

package/plugin/skills/ase-code-refactor/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: ase-code-refactor
-argument-hint: "[--help|-h] [--auto|-a] [--next|-n <option>] [<task-id>:] <request>"
+argument-hint: "[--help|-h] [--auto|-a] [--dry|-d] [--next|-n <option>[,...]] [<task-id>:] <request>"
 description: >
     Refactor Code Base:
     Use when user wants to refactor the code base.
 user-invocable: true
 disable-model-invocation: false
-effort: high
+effort: xhigh
 allowed-tools:
     - "Skill"
     - "Agent"
@@ -23,7 +23,7 @@ Refactor Artifacts
 
 <expand name="getopt"
     arg1="ase-code-refactor"
-    arg2="--auto|-a --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)">
+    arg2="--auto|-a --dry|-d --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)...">
     $ARGUMENTS
 </expand>
 
@@ -32,7 +32,7 @@ Refactor Artifacts
 <request><getopt-arguments/></request>
 </objective>
 
-@${CLAUDE_SKILL_DIR}/../../meta/ase-plan.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-format-plan.md
 
 Procedure
 ---------
@@ -161,7 +161,10 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
     You *MUST* perform the following sub-steps *internally* and *without
     any output* until and including the recommendation decision. Only
-    sub-step 4 below is allowed to produce output.
+    sub-steps 4-6 below are allowed to produce output, and only if
+    <getopt-option-auto/> is equal `false`. If <getopt-option-auto/> is
+    equal `true`, *skip* the reporting sub-steps 4-6 entirely (perform
+    no output at all) to speed up processing.
 
     1.  *Propose* corresponding *refactoring approach*, including
         optionally, some *alternative* refactoring approaches. Do *not*
@@ -252,6 +255,18 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         the information from refactoring A<n/> and all derived realization
         decisions into it. Store the resulting task plan in <content/>.
 
+        If a `CHANGELOG.md` file exists in the project (or in any
+        affected sub-package), the plan *MUST* include, as part of its
+        `## ※ CHANGES` section, an explicit bullet point describing
+        the addition of a corresponding new entry to that `CHANGELOG.md`
+        file, aligned with its existing style and conventions.
+
+        <if condition="<getopt-option-dry/> is equal `true`">
+        You *MUST* completely omit the `## ※ VERIFICATION` section
+        (including its heading and all of its bullet points) from
+        <content/>.
+        </if>
+
         You *MUST* *NOT* call `Edit`, `Write`, `NotebookEdit`, or any
         filesystem-modifying tool during this step.
 
@@ -273,23 +288,42 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
     5.  Directly pass-through control to the next skill:
 
-        1.  <if condition="<getopt-option-next/> is equal `IMPLEMENT`">
-            Call the tool `Skill(skill: "ase:ase-task-implement")` to
-            *implement* the freshly composed plan, bypassing `ase-task-edit`.
+        Treat <getopt-option-next/> as a comma-separated chronological
+        list of pre-selected next-step tokens. *Peek* the *first* token
+        as <head/> (or `none` if the list is `none`/empty).
+
+        1.  <if condition="<head/> is equal `IMPLEMENT`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). Set
+            <args></args> (empty).
+            <if condition="<getopt-option-next/> is not equal `none`">
+            Set <args>--next <getopt-option-next/></args> (forward
+            remaining list tokens to the downstream skill).
+            </if>
+            Call the tool `Skill(skill: "ase:ase-task-implement", args: <args/>)`
+            to *implement* the freshly composed plan, bypassing `ase-task-edit`.
             </if>
 
-        2.  <if condition="<getopt-option-next/> is equal `PREFLIGHT`">
-            Call the tool `Skill(skill: "ase:ase-task-preflight")` to
-            *preflight* the freshly composed plan, bypassing `ase-task-edit`.
+        2.  <if condition="<head/> is equal `PREFLIGHT`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). Set
+            <args></args> (empty).
+            <if condition="<getopt-option-next/> is not equal `none`">
+            Set <args>--next <getopt-option-next/></args> (forward
+            remaining list tokens to the downstream skill).
+            </if>
+            Call the tool `Skill(skill: "ase:ase-task-preflight", args: <args/>)`
+            to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </if>
 
         3.  <if condition="
-                <getopt-option-next/> is not equal `IMPLEMENT` AND
-                <getopt-option-next/> is not equal `PREFLIGHT`
+                <head/> is not equal `IMPLEMENT` AND
+                <head/> is not equal `PREFLIGHT`
             ">
-            Set <args></args> (set args to empty).
+            Forward the *entire* (unshifted) list to `ase-task-edit`, which
+            will consume its head itself. Set <args></args> (empty).
             <if condition="<getopt-option-next/> is not equal `none`">
-            Set <args><args/> --next <getopt-option-next/></args> (append to args).
+            Set <args>--next <getopt-option-next/></args> (append to args).
             </if>
             Then call the tool `Skill(skill: "ase:ase-task-edit", args: <args/>)`.
             </if>

package/plugin/skills/ase-code-refactor/help.md

@@ -8,7 +8,8 @@
 `ase-code-refactor`
     [`--help`|`-h`]
     [`--auto`|`-a`]
-    [`--next`|`-n` *option*]
+    [`--dry`|`-d`]
+    [`--next`|`-n` *option*[,...]]
     [*task-id*:] *request*
 
 ##  DESCRIPTION
@@ -31,13 +32,28 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
     Automatically pick the recommended refactoring approach without
     asking the user via the interactive dialog.
 
-`--next`|`-n` *option*:
-    Automatically choose the next step after composing the plan,
-    where *option* is either `none` (default, hand-off to
-    `ase-task-edit` interactively), `DONE` (stop), `EDIT` (hand off
-    to `ase-task-edit`), `PREFLIGHT` (hand off to
-    `ase-task-preflight`), or `IMPLEMENT` (hand off to
-    `ase-task-implement`).
+`--dry`|`-d`:
+    Compose the plan *without* the `※ VERIFICATION` section. When
+    `ase-task-implement` later applies such a plan, it strictly skips
+    the entire verification phase (no build, tests, linter,
+    type-checker, or program execution) once the source files have
+    been modified.
+
+`--next`|`-n` *option*[,...]:
+    Automatically choose the next step after composing the plan.
+    *option* is a single token or a *comma-separated chronological
+    list* of tokens; an `IMPLEMENT` or `PREFLIGHT` head token is
+    consumed by this skill (bypassing `ase-task-edit`), and any
+    remaining tokens are *forwarded* (via `--next`) to the downstream
+    skill. For all other head tokens, the *entire* list is forwarded
+    to `ase-task-edit`, which consumes its head itself. This lets an
+    entire pipeline be pre-scripted in one shot. Recognized tokens at
+    this skill: `none` (default, hand-off to `ase-task-edit`
+    interactively), `DONE` (stop), `EDIT` (hand off to
+    `ase-task-edit`), `PREFLIGHT` (hand off to `ase-task-preflight`),
+    or `IMPLEMENT` (hand off to `ase-task-implement`). Example:
+    `--next PREFLIGHT,IMPLEMENT,DONE` refactors, preflights, implements,
+    and exits without further dialog.
 
 ##  ARGUMENTS
 

package/plugin/skills/ase-code-resolve/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: ase-code-resolve
-argument-hint: "[--help|-h] [--auto|-a] [--next|-n <option>] [<task-id>:] <problem>"
+argument-hint: "[--help|-h] [--auto|-a] [--dry|-d] [--next|-n <option>[,...]] [<task-id>:] <problem>"
 description: >
     Resolve Problem:
     Use when user wants a bug fixed or problem resolved.
 user-invocable: true
 disable-model-invocation: false
-effort: high
+effort: xhigh
 allowed-tools:
     - "Skill"
     - "Agent"
@@ -23,7 +23,7 @@ Resolve Problem
 
 <expand name="getopt"
     arg1="ase-code-resolve"
-    arg2="--auto|-a --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)">
+    arg2="--auto|-a --dry|-d --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)...">
     $ARGUMENTS
 </expand>
 
@@ -32,7 +32,7 @@ Resolve Problem
 <problem><getopt-arguments/></problem>
 </objective>
 
-@${CLAUDE_SKILL_DIR}/../../meta/ase-plan.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-format-plan.md
 
 Procedure
 ---------
@@ -210,7 +210,10 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
     You *MUST* perform the following sub-steps *internally* and *without
     any output* until and including the recommendation decision. Only
-    sub-step 4 below is allowed to produce output.
+    sub-steps 4-6 below are allowed to produce output, and only if
+    <getopt-option-auto/> is equal `false`. If <getopt-option-auto/> is
+    equal `true`, *skip* the reporting sub-steps 4-6 entirely (perform
+    no output at all) to speed up processing.
 
     1.  *Propose* corresponding *resolution approach*, including optionally,
         some *alternative* resolution approaches. Do *not* output anything
@@ -300,6 +303,18 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         the success of the resolution, by using the <format/> defined for a
         task plan. Store the resulting task plan in <content/>.
 
+        If a `CHANGELOG.md` file exists in the project (or in any
+        affected sub-package), the plan *MUST* include, as part of its
+        `## ※ CHANGES` section, an explicit bullet point describing
+        the addition of a corresponding new entry to that `CHANGELOG.md`
+        file, aligned with its existing style and conventions.
+
+        <if condition="<getopt-option-dry/> is equal `true`">
+        You *MUST* completely omit the `## ※ VERIFICATION` section
+        (including its heading and all of its bullet points) from
+        <content/>.
+        </if>
+
         You *MUST* *NOT* call `Edit`, `Write`, `NotebookEdit`, or any
         filesystem-modifying tool during this step.
 
@@ -328,23 +343,42 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
     6.  Directly pass-through control to the next skill:
 
-        1.  <if condition="<getopt-option-next/> is equal `IMPLEMENT`">
-            Call the tool `Skill(skill: "ase:ase-task-implement")` to
-            *implement* the freshly composed plan, bypassing `ase-task-edit`.
+        Treat <getopt-option-next/> as a comma-separated chronological
+        list of pre-selected next-step tokens. *Peek* the *first* token
+        as <head/> (or `none` if the list is `none`/empty).
+
+        1.  <if condition="<head/> is equal `IMPLEMENT`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). Set
+            <args></args> (empty).
+            <if condition="<getopt-option-next/> is not equal `none`">
+            Set <args>--next <getopt-option-next/></args> (forward
+            remaining list tokens to the downstream skill).
+            </if>
+            Call the tool `Skill(skill: "ase:ase-task-implement", args: <args/>)`
+            to *implement* the freshly composed plan, bypassing `ase-task-edit`.
             </if>
 
-        2.  <if condition="<getopt-option-next/> is equal `PREFLIGHT`">
-            Call the tool `Skill(skill: "ase:ase-task-preflight")` to
-            *preflight* the freshly composed plan, bypassing `ase-task-edit`.
+        2.  <if condition="<head/> is equal `PREFLIGHT`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). Set
+            <args></args> (empty).
+            <if condition="<getopt-option-next/> is not equal `none`">
+            Set <args>--next <getopt-option-next/></args> (forward
+            remaining list tokens to the downstream skill).
+            </if>
+            Call the tool `Skill(skill: "ase:ase-task-preflight", args: <args/>)`
+            to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </if>
 
         3.  <if condition="
-                <getopt-option-next/> is not equal `IMPLEMENT` AND
-                <getopt-option-next/> is not equal `PREFLIGHT`
+                <head/> is not equal `IMPLEMENT` AND
+                <head/> is not equal `PREFLIGHT`
             ">
-            Set <args></args> (set args to empty).
+            Forward the *entire* (unshifted) list to `ase-task-edit`, which
+            will consume its head itself. Set <args></args> (empty).
             <if condition="<getopt-option-next/> is not equal `none`">
-            Set <args><args/> --next <getopt-option-next/></args> (append to args).
+            Set <args>--next <getopt-option-next/></args> (append to args).
             </if>
             Then call the tool `Skill(skill: "ase:ase-task-edit", args: <args/>)`.
             </if>

package/plugin/skills/ase-code-resolve/help.md

@@ -8,7 +8,8 @@
 `ase-code-resolve`
     [`--help`|`-h`]
     [`--auto`|`-a`]
-    [`--next`|`-n` *option*]
+    [`--dry`|`-d`]
+    [`--next`|`-n` *option*[,...]]
     [*task-id*:] *problem*
 
 ##  DESCRIPTION
@@ -36,13 +37,28 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
     Automatically pick the recommended resolution approach without
     asking the user via the interactive dialog.
 
-`--next`|`-n` *option*:
-    Automatically choose the next step after composing the plan,
-    where *option* is either `none` (default, hand-off to
-    `ase-task-edit` interactively), `DONE` (stop), `EDIT` (hand off
-    to `ase-task-edit`), `PREFLIGHT` (hand off to
-    `ase-task-preflight`), or `IMPLEMENT` (hand off to
-    `ase-task-implement`).
+`--dry`|`-d`:
+    Compose the plan *without* the `※ VERIFICATION` section. When
+    `ase-task-implement` later applies such a plan, it strictly skips
+    the entire verification phase (no build, tests, linter,
+    type-checker, or program execution) once the source files have
+    been modified.
+
+`--next`|`-n` *option*[,...]:
+    Automatically choose the next step after composing the plan.
+    *option* is a single token or a *comma-separated chronological
+    list* of tokens; an `IMPLEMENT` or `PREFLIGHT` head token is
+    consumed by this skill (bypassing `ase-task-edit`), and any
+    remaining tokens are *forwarded* (via `--next`) to the downstream
+    skill. For all other head tokens, the *entire* list is forwarded
+    to `ase-task-edit`, which consumes its head itself. This lets an
+    entire pipeline be pre-scripted in one shot. Recognized tokens at
+    this skill: `none` (default, hand-off to `ase-task-edit`
+    interactively), `DONE` (stop), `EDIT` (hand off to
+    `ase-task-edit`), `PREFLIGHT` (hand off to `ase-task-preflight`),
+    or `IMPLEMENT` (hand off to `ase-task-implement`). Example:
+    `--next IMPLEMENT,DONE` resolves the problem, implements it, and
+    exits without further dialog.
 
 ##  ARGUMENTS
 

package/plugin/skills/ase-meta-changes/SKILL.md

@@ -5,7 +5,7 @@ description: >
     Update changes entries in CHANGELOG.md files
 user-invocable: true
 disable-model-invocation: false
-effort: medium
+effort: high
 allowed-tools:
     - "Bash(git log *)"
     - "Bash(git diff *)"

package/plugin/skills/ase-meta-chat/SKILL.md

@@ -7,7 +7,7 @@ description: >
     DeepSeek or xAI Grok should be queried with a single chat message.
 user-invocable: true
 disable-model-invocation: false
-effort: low
+effort: medium
 allowed-tools:
     - "Agent"
 ---

package/plugin/skills/ase-meta-diaboli/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: ase-meta-diaboli
+argument-hint: "[--help|-h] <thesis>"
+description: >
+    Challenge a thesis by playing "Devil’s Advocate" (latin: "Advocatus
+    Diaboli"). Use when the user wants a thesis or statement
+    relentlessly challenged or criticised.
+user-invocable: true
+disable-model-invocation: false
+effort: xhigh
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+
+<skill name="ase-meta-diaboli">
+    Play "Devil's Advocate"
+</skill>
+
+<objective>
+    Play "Devil’s Advocate" (latin: "Advocatus Diaboli") by relentlessly
+    challenging or criticising the thesis: <thesis>$ARGUMENTS</thesis>
+</objective>
+
+1.  **Repeat Thesis**:
+
+    Output the thesis with the following <template/>:
+
+    <template>
+    &#x26AA; **THESIS**: <thesis/>
+    </template>
+
+2.  **Determine Anti-Thesis**:
+
+    Reason on the thesis in <thesis/> by playing *Devil’s Advocate*
+    (latin: *Advocatus Diaboli*) by relentlessly challenging or
+    criticising it with the help of the following tenets:
+
+    -   **Steelmanning**:
+        Attack the strongest ("steelman") interpretation of the
+        <thesis/>, not the weakest ("strawman"), because defeating a
+        strawman proves nothing.
+
+    -   **Stress-Testing Fundamentals**:
+        Identify weaknesses already in the fundamental ideas behind the
+        thesis, because if the foundation is already cracked, no amount
+        of polish on the surface can save what is built on top of it.
+
+    -   **Target Claims, Not Person**:
+        Critique the thesis, the assumption, the evidence — never the
+        proponent's competence or motives, because the moment it gets
+        personal, the inquiry dies.
+
+    -   **Make the Implicit Explicit**:
+        Surface the unstated assumptions the thesis silently depends on,
+        because most weak arguments hide in premises nobody bothered to say
+        out loud.
+
+    -   **Demand Evidence Proportional to Claim**:
+        Ask "How do we know this?" and "What would it take to be true?",
+        because extraordinary claims need extraordinary support and
+        comfortable consensus needs scrutiny most of all.
+
+    -   **Seek the Disconfirming Case**:
+        Actively hunt for the counterexample, the edge case, the scenario
+        where the position fails, because one solid counterexample outweighs
+        ten confirmations.
+
+    -   **Risk Identification**:
+        Focus on potential problems in the thesis with the highest
+        potential risk only, because low-risk problems are not worth the
+        explicit discussion.
+
+    -   **Push the Logic to its Conclusion**:
+        Ask "If we accept this, then what?" and apply "Reduction to
+        Absurdity" (latin: "Reductio Ad Absurdum"), because this disproves
+        the thesis by showing that accepting it leads to a logically
+        absurd, contradictory, or impossible conclusion.
+
+    -   **Expose Hidden Costs and Trade-Offs**:
+        Name the opportunity cost, the maintenance burden, the failure mode
+        nobody priced in, because every choice in the thesis forecloses
+        alternatives.
+
+    -   **Stay Falsifiable and Concrete**:
+        Frame objections so they can be answered or dismissed with facts,
+        because vague unease ("I just don't like it") is just noise.
+
+    -   **Argue in Good Faith**:
+        Make clear you're just stress-testing the thesis, not
+        obstructing, because the goal of the objective is a better final
+        decision, not winning.
+
+    -   **Know When to Yield**:
+        Conceding when the argument holds is what makes the challenge
+        credible, because a Devil's Advocate who can never be satisfied is
+        just a contrarian.
+
+    -   **Pre-Mortem Thinking**:
+        Imagine failure scenarios of the thesis, because better to
+        prevent them in advance than having to resolve them later.
+
+    For each Anti-Thesis or Counter-Argument rank it on a Likert scale
+    of 0 (weak) to 10 (strong). Repeat the process of finding more
+    Anti-Theses or Counter-Arguments until you EITHER have found at
+    least 10 Anti-Theses or Counter-Arguments with at least a rank
+    of 7 OR you have already checked a total of 50 Anti-Theses or
+    Counter-Arguments.
+
+    Then, for the top-10 highest-ranked Anti-Theses or
+    Counter-Arguments, sort them by their rank from highest to lowest,
+    store each in <antithesis-N/> with the format `**<aspect-N/>**
+    (rank: <rank-N/>/10): <statement-N/>` (where <aspect-N/> is a short
+    1-3 word summary of <statement-N/>, <rank-N/> is the determined
+    rank on the Likert scale, and <statement-N/> is a single-sentence
+    statement of not more than 40 words), and then output the following
+    <template/>:
+
+    <template>
+    &#x1F7E0; **ANTITHESIS**: <antithesis-N/>
+    </template>
+
+3.  **Dialectical Reasoning**:
+
+    Following the Hegelian dialectics of...
+
+        *Thesis* + *Antithesis* → *Synthesis*
+
+    ...with...
+
+    -   *Thesis*: the initial statement, claim, or position. It is asserted
+        as true, but on its own it is one-sided: it captures part of the truth
+        while ignoring its own limits, gaps, or internal tensions.
+
+    -   *Antithesis*: the opposing force. It is the contradiction,
+        objection, or counter-position that the thesis provokes — precisely
+        the role a Devil's Advocate played. The antithesis exposes what the
+        thesis omitted or got wrong.
+
+    -   *Synthesis*: the resolution. Not a mushy "average" of the two, and
+        not the victory of one over the other, but a higher position that
+        preserves what was true in both while discarding what was false. The
+        synthesis transcends the conflict by reframing it.
+
+    ...finally derive a strong single-sentence (not more than 40 words)
+    synthesis of the <thesis/> and all found <antithesis-N/>, store it
+    in <synthesis/>, and then finally output the following <template/>:
+
+    <template>
+    &#x1F535; **SYNTHESIS**: <synthesis/>
+    </template>
+

package/plugin/skills/ase-meta-diaboli/help.md

@@ -0,0 +1,60 @@
+
+##  NAME
+
+`ase-meta-diaboli` - Play "Devil's Advocate" (latin: "Advocatus Diaboli")
+
+##  SYNOPSIS
+
+`ase-meta-diaboli`
+    [`--help`|`-h`]
+    *thesis*
+
+##  DESCRIPTION
+
+The `ase-meta-diaboli` skill plays *Devil's Advocate* (latin:
+*Advocatus Diaboli*) by relentlessly challenging or criticising a
+supplied *thesis*. It applies a disciplined set of critical-thinking
+tenets — steelmanning, stress-testing fundamentals, surfacing implicit
+assumptions, demanding proportional evidence, seeking disconfirming
+cases, *Reductio Ad Absurdum*, exposing hidden costs, and pre-mortem
+thinking — while targeting the claim rather than its proponent and
+yielding where the argument genuinely holds.
+
+The skill iterates until it has found at least ten anti-theses
+(counter-arguments) each ranked at least 7 on a 0 (weak) to 10
+(strong) Likert scale, reports the top ten sorted from strongest to
+weakest, and finally applies *Hegelian dialectics* (*Thesis* +
+*Antithesis* → *Synthesis*) to derive a single-sentence *SYNTHESIS*
+that preserves what is true in both the thesis and its antitheses
+while discarding what is false.
+
+The intent is constructive: stress-testing the thesis in good faith to
+arrive at a better final decision, not obstructing or merely being
+contrarian.
+
+##  ARGUMENTS
+
+*thesis*:
+    The statement, claim, or position to be relentlessly challenged.
+    It may be technical, factual, or opinion-based; the skill attacks
+    its strongest ("steelman") interpretation.
+
+##  EXAMPLES
+
+Challenge a technology-choice claim:
+
+```text
+❯ /ase-meta-diaboli HAPI is the best REST framework
+```
+
+Stress-test a design decision:
+
+```text
+❯ /ase-meta-diaboli We should rewrite the service in Rust.
+```
+
+##  SEE ALSO
+
+`ase-meta-why`, `ase-meta-evaluate`, `ase-meta-quorum`,
+`ase-meta-persona`.
+

package/plugin/skills/ase-meta-persona/SKILL.md

@@ -10,7 +10,7 @@ description: >
     Use when user says "persona <persona>" or "be <persona>".
 user-invocable: true
 disable-model-invocation: false
-effort: medium
+effort: high
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md

package/plugin/skills/ase-meta-quorum/SKILL.md

@@ -5,7 +5,7 @@ description: >
     Query Multiple AIs for Quorum Answer.
 user-invocable: true
 disable-model-invocation: false
-effort: medium
+effort: high
 allowed-tools:
     - "Agent"
     - "TaskCreate"

package/plugin/skills/ase-meta-search/SKILL.md

@@ -6,7 +6,7 @@ description: >
     Prefer this skill before using Perplexity, Brave and WebSearch.
 user-invocable: true
 disable-model-invocation: false
-effort: low
+effort: medium
 allowed-tools:
     - "mcp__search-perplexity__perplexity_search"
     - "mcp__search-brave__brave_web_search"

package/plugin/skills/ase-meta-why/SKILL.md

@@ -5,7 +5,7 @@ description: >
     Five-Whys Root-Cause Analysis.
 user-invocable: true
 disable-model-invocation: false
-effort: medium
+effort: high
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@@ -27,7 +27,7 @@ addressing surface-level symptoms.
 </objective>
 
 <flow>
-1.  <step id="STEP 1: PROBLEM">
+1.  <step id="STEP 1: Determine Problem">
     State the problem statement.
 
     <template>
@@ -35,7 +35,7 @@ addressing surface-level symptoms.
     </template>
     </step>
 
-2.  <step id="STEP 2: ROOT-CAUSE ANALYSIS">
+2.  <step id="STEP 2: Root-Cause Analysis">
     Find the root-cause of <problem/> by following the following iteration cycle.
     Start with a <question/> set equal to the <problem/>.
 
@@ -55,7 +55,7 @@ addressing surface-level symptoms.
     </for>
     </step>
 
-3.  <step id="STEP 3: SOLUTION">
+3.  <step id="STEP 3: Report Solution">
     Validate the root-cause by working backwards the causality chain.
     Propose a solution that addresses and solves the root-cause.
     For the proposed solution, optionally directly propose corresponding source code changes.

package/plugin/skills/ase-task-delete/SKILL.md

@@ -6,8 +6,8 @@ description: >
     Use when the user calls to "delete", "remove" or "clear" the
     "task", "plan", "spec", or "specification".
 user-invocable: true
-disable-model-invocation: false
-effort: low
+disable-model-invocation: true
+effort: high
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md