@rse/ase 0.9.3 → 0.9.5

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

@@ -1,6 +1,6 @@
 ---
 name: ase-meta-search
-argument-hint: "[--help|-h] <query>"
+argument-hint: "[--help|-h] [--services|-s=(all|perplexity|brave|exa|websearch)...] <query>"
 description: >
     Search the Internet/Web with a query.
     Prefer this skill before using Perplexity, Brave and WebSearch.
@@ -17,14 +17,21 @@ allowed-tools:
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
 <skill name="ase-meta-search">
 Search the Internet/Web
 </skill>
 
+<expand name="getopt"
+    arg1="ase-meta-search"
+    arg2="--services|-s=(all|perplexity|brave|exa|websearch)...">
+    $ARGUMENTS
+</expand>
+
 <objective>
 Your objective is to *search* the *Internet*/*Web* for the following query:
-<query>$ARGUMENTS</query>
+<query><getopt-arguments/></query>
 </objective>
 
 <flow>
@@ -34,7 +41,7 @@ Your objective is to *search* the *Internet*/*Web* for the following query:
     <define name="agent">
     ```text
         Agent(
-            name:          "ase:ase-meta-search",
+            name:          "ase-meta-search",
             description:   "Query Web Search Service",
             subagent_type: "ase:ase-meta-search",
             prompt:        <content/>
@@ -42,24 +49,46 @@ Your objective is to *search* the *Internet*/*Web* for the following query:
     ```
     </define>
 
-    If the MCP tool `perplexity_search` from the MCP server `search-perplexity` is available:
+    Treat <getopt-option-services/> as a comma-separated list of
+    *backend tokens*. The getopt parser validates only the *first*
+    token, so you *MUST* validate each remaining token yourself against
+    the allowed set `all`, `perplexity`, `brave`, `exa`, `websearch`. If
+    any token is *not* in this set, only output the following <template/>
+    and then immediately *STOP* processing the entire current skill:
+
+    <template>
+    ⧉ **ASE**: ✪ skill: **ase-meta-search**, ▶ ERROR: invalid `--services` token: **<token/>**
+    </template>
+
+    A backend is *selected* if `all` is in <getopt-option-services/> *OR*
+    that backend's own name is in <getopt-option-services/>.
+
+    If the `perplexity` backend is *selected* and the MCP tool
+    `perplexity_search` from the MCP server `search-perplexity` is available:
+
     <expand name="agent">
         Call the MCP tool `perplexity_search(query: "<query/>")`
         from the MCP server `search-perplexity`.
     </expand>
 
-    If the MCP tool `brave_web_search` from the MCP server `search-brave` is available:
+    If the `brave` backend is *selected* and the MCP tool
+    `brave_web_search` from the MCP server `search-brave` is available:
+
     <expand name="agent">
         Call the MCP tool `brave_web_search(query: "<query/>")`
         from the MCP server `search-brave`.
     </expand>
 
-    If the MCP tool `web_search_exa` from the MCP server `search-exa` is available:
+    If the `exa` backend is *selected* and the MCP tool
+    `web_search_exa` from the MCP server `search-exa` is available:
+
     <expand name="agent">
         Call the MCP tool `web_search_exa(query: "<query/>")`
         from the MCP server `search-exa`.
     </expand>
 
+    If the `websearch` backend is *selected*:
+
     <expand name="agent">
         Call the tool `WebSearch(query: "<query/>")`.
     </expand>

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

@@ -7,12 +7,13 @@
 
 `ase-meta-search`
     [`--help`|`-h`]
+    [`--services`|`-s`=(`all`|`perplexity`|`brave`|`exa`|`websearch`)...]
     *query*
 
 ##  DESCRIPTION
 
 The `ase-meta-search` skill searches the *Internet*/*Web* for the
-given *query*. It dispatches the query in parallel to all available
+given *query*. It dispatches the query in parallel to the *selected*
 search services (Perplexity, Brave, Exa, and Claude's built-in
 `WebSearch`) via the `ase:ase-meta-search` sub-agent and consolidates
 all responses into a single answer without removing original
@@ -23,17 +24,28 @@ Brave, or `WebSearch` individually.
 
 ##  ARGUMENTS
 
+`--services`|`-s`=(`all`|`perplexity`|`brave`|`exa`|`websearch`)...:
+    The comma-separated list of search backends to query. The default
+    `all` queries every available backend (the original behavior);
+    otherwise only the listed backends are queried.
+
 *query*:
     The search query to dispatch to the search services.
 
 ##  EXAMPLES
 
-Search the Web for a topic:
+Search the Web for a topic across all backends:
 
 ```text
 ❯ /ase-meta-search latest stable release of TypeScript and release notes
 ```
 
+Search the Web using only the Brave and Exa backends:
+
+```text
+❯ /ase-meta-search --services=brave,exa latest stable release of TypeScript
+```
+
 ##  SEE ALSO
 
 `ase-meta-chat`, `ase-meta-quorum`, `ase-arch-discover`.

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

@@ -1,6 +1,6 @@
 ---
 name: ase-meta-steelman
-argument-hint: "[--help|-h] <thesis>"
+argument-hint: "[--help|-h] [--count|-c <count>] [--rounds|-r <rounds>] <thesis>"
 description: >
     Build the strongest possible case for a thesis by playing
     "Steelman" (Latin spirit: "Advocatus Dei"). Use when the user
@@ -12,25 +12,57 @@ effort: xhigh
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
 <skill name="ase-meta-steelman">
     Build the "Steelman" Argument
 </skill>
 
+<expand name="getopt"
+    arg1="ase-meta-steelman"
+    arg2="--count|-c=10 --rounds|-r=1">
+    $ARGUMENTS
+</expand>
+
 <objective>
     Build the "Steelman" argument by constructing the strongest
-    possible case for the thesis: <thesis>$ARGUMENTS</thesis>
+    possible case for the thesis: <thesis><getopt-arguments/></thesis>
 </objective>
 
-1.  **Repeat Thesis**:
+Determine the number of *rounds* to perform: set <rounds/> to
+<getopt-option-rounds/>; if <getopt-option-rounds/> is *non-numeric* or
+*less than or equal to 0*, use the default *1* instead.
+
+Determine the minimum number of *pro-theses* to surface: set <count/>
+to <getopt-option-count/>; if <getopt-option-count/> is *non-numeric* or
+*less than or equal to 0*, use the default *10* instead.
+
+<flow>
+
+1.  <step id="STEP 1: Restate Thesis">
+
+    Begin a *round* of fortification and consolidating reasoning. On
+    the first visit, set <i>1</i> (set round counter to one); on each
+    subsequent visit (via the jump back in the last step), <i/> has
+    already been incremented.
+
+    <if condition="<rounds/> is greater than 1">
+    Indicate the current round with the following <template/>:
+
+    <template>
+    <ase-tpl-bullet-secondary/> **ROUND**: <i/>/<rounds/>
+    </template>
+    </if>
 
     Output the thesis with the following <template/>:
 
     <template>
-    <ase-tpl-bullet-secondary/> **THESIS**: <thesis/>
+    <ase-tpl-bullet-normal/> **THESIS**: <thesis/>
     </template>
 
-2.  **Determine Pro-Theses**:
+    </step>
+
+2.  <step id="STEP 2: Determine Pro-Theses">
 
     Reason on the thesis in <thesis/> by playing *Steelman* (Latin
     spirit: "Advocatus Dei") - building the strongest possible case
@@ -108,11 +140,11 @@ effort: xhigh
     For each Pro-Thesis or Supporting-Argument rank it on a Likert
     scale of 0 (weak) to 10 (strong). Repeat the process of finding
     more Pro-Theses or Supporting-Arguments until you EITHER have found
-    at least 10 Pro-Theses or Supporting-Arguments with at least a rank
-    of 7 OR you have already checked a total of 50 Pro-Theses or
-    Supporting-Arguments.
+    at least <count/> Pro-Theses or Supporting-Arguments with at least a
+    rank of 7 OR you have already checked a total of <count/> x 5
+    Pro-Theses or Supporting-Arguments.
 
-    Then, for the top-10 highest-ranked Pro-Theses or
+    Then, for the top-<count/> highest-ranked Pro-Theses or
     Supporting-Arguments, sort them by their rank from highest to lowest,
     store each in <prothesis-N/> with the format `**<aspect-N/>**
     (rank: <rank-N/>/10): <statement-N/>` (where <aspect-N/> is a short
@@ -124,8 +156,9 @@ effort: xhigh
     <template>
     <ase-tpl-bullet-signal/> **PRO-THESIS**: <prothesis-N/>
     </template>
+    </step>
 
-3.  **Consolidating Reasoning**:
+3.  <step id="STEP 3: Consolidating Reasoning">
 
     Following the consolidation of...
 
@@ -149,7 +182,7 @@ effort: xhigh
         while honestly bounding where it holds. The fortification reinforces
         the position by sharpening it.
 
-    ...finally derive a strong single-sentence (not more than 40 words)
+    ...then derive a strong single-sentence (not more than 40 words)
     fortification of the <thesis/> and all found <prothesis-N/> - the
     strongest defensible form of the thesis - store it in <fortification/>,
     and then finally output the following <template/>:
@@ -157,3 +190,21 @@ effort: xhigh
     <template>
     <ase-tpl-bullet-normal/> **FORTIFICATION**: <fortification/>
     </template>
+
+    Finally, decide whether to perform a further round:
+
+    <if condition="<i/> is less than <rounds/>">
+    Carry the result forward to the next round: set
+    <thesis><fortification/></thesis> (the fortification becomes the
+    thesis to be strengthened next), set <i/> to <i/> + 1 (increment the
+    round counter), and then *CONTINUE* the *LOOP* at **STEP 1**!
+    </if>
+
+    <if condition="<i/> is greater than or equal to <rounds/>">
+    All <rounds/> rounds are complete; *STOP* the loop here.
+    Do not output any further explanations.
+    </if>
+
+    </step>
+
+</flow>

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

@@ -7,6 +7,8 @@
 
 `ase-meta-steelman`
     [`--help`|`-h`]
+    [`--count`|`-c` *count*]
+    [`--rounds`|`-r` *rounds*]
     *thesis*
 
 ##  DESCRIPTION
@@ -21,20 +23,44 @@ surfacing the upside, and pre-parade thinking - while crediting the
 claim rather than the proponent's authority and conceding where the
 thesis genuinely falls short.
 
-The skill iterates until it has found at least ten pro-theses
+The skill iterates until it has found at least *count* pro-theses
 (supporting arguments) each ranked at least 7 on a 0 (weak) to 10
-(strong) Likert scale, reports the top ten sorted from strongest to
+(strong) Likert scale, reports the top *count* sorted from strongest to
 weakest, and finally consolidates them (*Thesis* + *Pro-Theses* →
 *Fortification*) to derive a single-sentence *FORTIFICATION* that
 consolidates everything genuinely strengthening the thesis while
 honestly bounding where it holds.
 
+The `--rounds`/`-r` *rounds* option turns the single defense pass into an
+*iterative chain* of *rounds* rounds (default *1*): each round's
+*FORTIFICATION* becomes the *thesis* of the next round, so the position
+is progressively re-fortified and sharpened. A `0`, negative, or
+non-numeric value falls back to the default *1*; with a single round the
+output is identical to running without the option.
+
+The `--count`/`-c` *count* option sets the minimum number of strong
+pro-theses to surface (default *10*), raising or lowering the floor of
+supporting arguments hunted for, sorted, and reported in each defense
+pass. A `0`, negative, or non-numeric value falls back to the default
+*10*.
+
 The intent is constructive: building the best honest case for the
 thesis to arrive at a better final decision, not overselling or merely
 cheerleading.
 
 ##  ARGUMENTS
 
+`--count`, `-c` *count*:
+    Surface at least *count* strong pro-theses (default *10*) per defense
+    pass before sorting and reporting the top *count* and deriving the
+    *FORTIFICATION*. An invalid or non-positive *count* reverts to the
+    default *10*.
+
+`--rounds`, `-r` *rounds*:
+    Run *rounds* iterative defense rounds (default *1*), feeding each
+    round's *FORTIFICATION* in as the next round's *thesis*. An invalid
+    or non-positive *rounds* reverts to the default *1*.
+
 *thesis*:
     The statement, claim, or position to be charitably strengthened.
     It may be technical, factual, or opinion-based; the skill defends
@@ -54,6 +80,12 @@ Build the case for a design decision:
 ❯ /ase-meta-steelman We should rewrite the service in Rust.
 ```
 
+Strengthen across five iterative rounds:
+
+```text
+❯ /ase-meta-steelman --rounds 5 We should rewrite the service in Rust.
+```
+
 ##  SEE ALSO
 
 `ase-meta-diaboli`, `ase-meta-why`, `ase-meta-evaluate`,

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

@@ -1,6 +1,6 @@
 ---
 name: ase-meta-why
-argument-hint: "[--help|-h] <fact>"
+argument-hint: "[--help|-h] [--depth|-d <N>] [--width|-w <M>] <fact>"
 description: >
     Five-Whys Root-Cause Analysis.
 user-invocable: true
@@ -10,16 +10,23 @@ effort: high
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
 <skill name="ase-meta-why">
 Five-Whys Root-Cause Analysis
 </skill>
 
+<expand name="getopt"
+    arg1="ase-meta-why"
+    arg2="--depth|-d=5 --width|-w=1">
+    $ARGUMENTS
+</expand>
+
 <objective>
 Apply the *Five-Whys* *root-cause analysis* technique to investigate
 the following problem:
 
-<problem>Why $ARGUMENTS?</problem>
+<problem>Why <getopt-arguments/>?</problem>
 
 For this, iteratively ask "why" to drill down from symptoms to the root-cause.
 This helps to identify the fundamental reason behind a problem rather than just
@@ -27,42 +34,140 @@ addressing surface-level symptoms.
 </objective>
 
 <flow>
-1.  <step id="STEP 1: Determine Problem">
+
+1.  <step id="STEP 1: Restate Problem">
+
     State the problem statement.
 
     <template>
     <ase-tpl-bullet-signal/> **PROBLEM**: <problem/>
     </template>
+
     </step>
 
 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/>.
 
-    <for items="1 2 3 4 5">
-        Ask <question/> and document the answer in <answer/> with the following template:
-        Don't stop at symptoms, keep digging for systemic issues.
-        Multiple root-causes may exist -- explore different branches.
-        Consider technical, domain-specific, process-related, or organizational causes.
+    Determine the *maximum chain length* from <getopt-option-depth/>:
+    set <depth/> to <getopt-option-depth/>; if <getopt-option-depth/>
+    is *non-numeric* or *less than or equal to 0*, use the default *5* instead.
+
+    Determine the *maximum chain width* from <getopt-option-width/>:
+    set <width/> to <getopt-option-width/>; if <getopt-option-width/>
+    is *non-numeric* or *less than or equal to 0*, use the default *1* instead.
+
+    -   <if condition="<width/> is less than or equal to 1">
+
+        Walk a *single* causality chain (the classic Five-Whys):
+
+        Start with <n>1</n> (set iteration counter to one).
+
+        <while condition="<n/> is less than or equal to <depth/>">
+
+            Ask <question/> and document the answer in <answer/> with the following template:
+            Don't stop at symptoms, keep digging for systemic issues.
+            Consider technical, domain-specific, process-related, or organizational causes.
+
+            <template>
+            <ase-tpl-bullet-secondary/> **WHY <n/>**: <answer/>
+            </template>
+
+            Then, for the next iteration set <question/> now to be the last <answer/>.
+            The magic is NOT in exactly <depth/> "Why" -- you can <break/>
+            the iteration when you already reached the root-cause.
+            Finally, set <n/> to <n/> + 1 (increment iteration counter).
+
+        </while>
+
+        </if>
+
+    -   <if condition="<width/> is greater than 1">
 
-        <template>
-        <ase-tpl-bullet-secondary/> **WHY <item/>**: <answer/>
-        </template>
+        Walk a *widened* causality chain: at each "why" level, surface up to
+        <width/> *candidate* sub-causes, then commit to the single most
+        significant one and descend into it (the chain stays single-rooted --
+        the extra candidates are *not* each drilled to their own root-cause).
+        Their purpose is to guard against *premature commitment* to the wrong
+        sub-cause: by enumerating the plausible alternatives at each level, the
+        chosen descent is a *justified* selection rather than the first
+        plausible answer, and the unchosen candidates remain on record as
+        *fallbacks* to backtrack into (see STEP 3) should the chosen path fail
+        validation.
+
+        Remember the *unchosen* candidates of every level (keep them in
+        <fallbacks/>, tagged by their level <n/>), so STEP 3 can backtrack
+        into them.
+
+        Start with <n>1</n> (set iteration counter to one).
+
+        <while condition="<n/> is less than or equal to <depth/>">
+
+            Ask <question/> and surface up to <width/> *distinct*,
+            *non-overlapping* candidate sub-causes, each documented in <answer-k/>.
+            Don't stop at symptoms, keep digging for systemic issues.
+            Explore *different* candidates -- technical, domain-specific,
+            process-related, or organizational causes -- and avoid restating
+            the same cause in different words.
+
+            Start with <k>1</k> (set candidate counter to one).
+            <while condition="<k/> is less than or equal to <width/>">
+                <template>
+                <ase-tpl-bullet-secondary/> **WHY <n/>.<k/>**: <answer-k/>
+                </template>
+                Set <k/> to <k/> + 1 (increment candidate counter).
+            </while>
+
+            Then choose, among the <answer-k/>, the *most causally-significant*
+            candidate -- the one most likely to lead to the true root-cause --
+            and *justify* the choice in one line (state explicitly *why* it
+            beats the other candidates, e.g. it alone also explains the timing,
+            scope, or magnitude of the level's fact). A bare "most significant"
+            is *not* sufficient; if no candidate clearly dominates, say so.
+
+            <template>
+            <ase-tpl-bullet-secondary/> **WHY <n/> → chosen <n/>.<chosen-k/>**: <justification/>
+            </template>
+
+            Record the remaining candidates as <fallbacks/> for level <n/>.
+            Then, for the next iteration, set <question/> to the chosen candidate.
+            You can <break/> the iteration when the chosen candidate already
+            reached its root-cause.
+            Finally, set <n/> to <n/> + 1 (increment iteration counter).
+
+        </while>
+
+        </if>
 
-        Then, for the next iteration set <question/> now to be the last <answer/>.
-        The magic is NOT in exactly 5 "Why" -- you can <break/> the iteration
-        when you already reached the root-cause.
-    </for>
     </step>
 
 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.
+
+    Validate the root-cause by working backwards along the chosen causality
+    chain: check, level by level, that each chosen sub-cause genuinely *causes*
+    the fact above it (and that fixing the final root-cause would dissolve the
+    whole chain up to the original <problem/>).
+
+    When <width/> is *greater than 1* and this backward validation *fails* at
+    some level -- i.e. the chosen sub-cause does *not* adequately explain the
+    fact above it -- *backtrack*: discard the chosen sub-cause from that level
+    downward, pick the next-best candidate from that level's <fallbacks/>, set
+    <question/> to it, and re-run the STEP 2 widened descent from there. Repeat
+    until a chain survives backward validation or that level's <fallbacks/> are
+    exhausted (then report the strongest chain found and note that no candidate
+    fully validated). This is the payoff of <width/> *greater than 1*: the
+    enumerated alternatives let the analysis *recover* from a wrong turn instead
+    of committing to a mis-rooted chain.
+
+    Propose a solution that addresses and solves the validated root-cause.
     For the proposed solution, optionally directly propose corresponding source code changes.
 
     <template>
     <ase-tpl-bullet-signal/> **SOLUTION**: <solution/>
     </template>
+
     </step>
+
 </flow>
 

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

@@ -7,20 +7,48 @@
 
 `ase-meta-why`
     [`--help`|`-h`]
+    [`--depth`|`-d` *N*]
+    [`--width`|`-w` *M*]
     *fact*
 
 ##  DESCRIPTION
 
 The `ase-meta-why` skill applies the *Five-Whys* *root-cause
 analysis* technique to the supplied *fact*. The skill iteratively
-asks "why" - up to five times - to drill down from surface symptoms
-to the underlying root cause, considering technical, domain-specific,
-process-related, and organizational causes. After identifying the
-root cause it proposes a *SOLUTION* that addresses it, optionally
-including concrete source code changes.
+asks "why" - up to *N* times (see `--depth`, default five) - to drill
+down from surface symptoms to the underlying root cause, considering
+technical, domain-specific, process-related, and organizational
+causes. By default it walks a *single* causality chain, but with
+`--width` *M* (> 1) it walks a *widened* chain: at each level it surfaces
+up to *M* candidate sub-causes, descends into the most significant one
+with an explicit justification for the choice, and keeps the unchosen
+candidates as *fallbacks*. If backward validation later shows the chosen
+path was mis-rooted, it *backtracks* into a fallback and re-descends -
+guarding against the classic Five-Whys failure of committing early to the
+wrong sub-cause. After identifying (and validating) the root cause it
+proposes a *SOLUTION* that addresses it, optionally including concrete
+source code changes.
 
 ##  ARGUMENTS
 
+`--depth`|`-d` *N*:
+    The *maximum* number of "why" iterations (the Five-Whys chain
+    length), acting as an *upper bound* only - the analysis still stops
+    early once the root cause is reached. Defaults to *5*. A non-numeric
+    or non-positive value falls back to the default.
+
+`--width`|`-w` *M*:
+    The *maximum* number of *candidate sub-causes* to surface per "why"
+    level. With the default *1*, the skill walks a single causality chain
+    (classic Five-Whys); with *M* > 1, each level surfaces up to *M*
+    candidate sub-causes, descends into the single most significant one
+    (justifying the choice), and retains the rest as *fallbacks*. During
+    backward validation a mis-rooted choice is *backtracked* into a fallback
+    and re-descended, so the widening actively improves which root-cause is
+    reached rather than merely listing alternatives. The result is still a
+    single, but better-justified, root-cause. A non-numeric or non-positive
+    value falls back to the default.
+
 *fact*:
     The observed *fact* (symptom, problem, or surprising outcome)
     whose root cause should be investigated. The skill implicitly
@@ -34,6 +62,19 @@ Investigate the root cause of a build failure:
 ❯ /ase-meta-why the CI build is intermittently failing on macOS runners
 ```
 
+Drill down deeper with a tunable chain length of seven:
+
+```text
+❯ /ase-meta-why -d 7 the production latency spiked after the last deploy
+```
+
+Weigh several candidate sub-causes per level (with backtracking) to avoid
+committing early to the wrong root-cause:
+
+```text
+❯ /ase-meta-why -w 3 the release was delayed by two weeks
+```
+
 ##  SEE ALSO
 
 `ase-code-analyze`, `ase-code-resolve`, `ase-arch-analyze`.

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

@@ -117,7 +117,7 @@ Procedure
 
     -   **Fuzzy Language**:
         When the user uses vague or overloaded terms instead of a precise
-        or canonical terms.
+        or canonical term.
 
     -   **Conflicting Terminology**:
         When the user uses a term that conflicts with the existing