@rse/ase 0.9.2 → 0.9.4

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

@@ -0,0 +1,210 @@
+---
+name: ase-meta-steelman
+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
+    wants a thesis or statement charitably strengthened and defended.
+user-invocable: true
+disable-model-invocation: false
+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><getopt-arguments/></thesis>
+</objective>
+
+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: Repeat 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-normal/> **THESIS**: <thesis/>
+    </template>
+
+    </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
+    *for* it - by charitably strengthening and defending it with the
+    help of the following tenets:
+
+    -   **Charitable Interpretation**:
+        Defend the strongest ("steelman") interpretation of the
+        <thesis/>, not the weakest ("strawman"), because the most
+        generous reading is the one worth defending and the one a fair
+        critic must ultimately confront.
+
+    -   **Strengthen the Fundamentals**:
+        Identify the soundest fundamental ideas behind the thesis and
+        make them explicit, because a position rests on the strength of
+        its foundation and a solid foundation carries everything built
+        on top of it.
+
+    -   **Credit Claims, Not Person**:
+        Support the thesis, the assumption, the evidence - never appeal
+        to the proponent's authority or reputation, because a case that
+        leans on who said it instead of what was said is no stronger
+        than its weakest argument.
+
+    -   **Make the Enabling Assumptions Explicit**:
+        Surface the reasonable assumptions the thesis depends on and
+        show they hold, because most strong arguments gain their force
+        from premises that are sound once stated out loud.
+
+    -   **Supply Evidence Proportional to Claim**:
+        Ask "How do we know this?" and "What best supports it?", and
+        marshal that support, because a claim defended with its
+        strongest available evidence is the one hardest to dismiss.
+
+    -   **Seek the Confirming Case**:
+        Actively hunt for the supporting example, the favourable
+        scenario, the precedent where the position succeeds, because
+        one solid confirming case anchors the argument in reality.
+
+    -   **Merit Identification**:
+        Focus on the genuine strengths of the thesis with the highest
+        potential value only, because marginal merits are not worth the
+        explicit discussion.
+
+    -   **Push the Logic to its Best Conclusion**:
+        Ask "If we accept this, then what follows?" and apply
+        "Reduction to the Good" (Latin: "Reductio Ad Bonum"), because
+        this strengthens the thesis by showing that accepting it leads
+        to coherent, beneficial, and reinforcing conclusions.
+
+    -   **Surface the Upside and Leverage**:
+        Name the opportunity gained, the compounding benefit, the
+        problem dissolved, because every choice in the thesis unlocks
+        possibilities that a fair appraisal must count.
+
+    -   **Stay Falsifiable and Concrete**:
+        Frame each supporting point so it can be checked and confirmed
+        with facts, because vague enthusiasm ("I just like it") adds no
+        strength to the case.
+
+    -   **Argue in Good Faith**:
+        Make clear you are building the best honest case, not
+        overselling, because the goal of the objective is a better
+        final decision, not a sales pitch.
+
+    -   **Concede the Real Weaknesses**:
+        Acknowledging where the thesis genuinely falls short is what
+        makes the defence credible, because a Steelman who can never
+        admit a flaw is just an apologist.
+
+    -   **Pre-Parade Thinking**:
+        Imagine success scenarios of the thesis, because envisioning
+        how it wins clarifies the conditions worth securing in advance.
+
+    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 <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-<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
+    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>
+    <ase-tpl-bullet-signal/> **PRO-THESIS**: <prothesis-N/>
+    </template>
+    </step>
+
+3.  <step id="STEP 3: Consolidating Reasoning">
+
+    Following the consolidation of...
+
+        *Thesis* + *Pro-Theses* → *Fortification*
+
+    ...with...
+
+    -   *Thesis*: the initial statement, claim, or position. It is asserted
+        as true, but on its own it is under-developed: it captures part of the
+        truth while leaving its own strongest support implicit, unstated, or
+        unproven.
+
+    -   *Pro-Theses*: the reinforcing forces. They are the corroboration,
+        evidence, or supporting positions that the thesis invites - precisely
+        the role a Steelman played. The pro-theses make explicit what the
+        thesis assumed or left unsaid.
+
+    -   *Fortification*: the consolidation. Not an uncritical "cheerleading"
+        of the thesis, and not a mere restatement of it, but a stronger
+        position that consolidates everything that genuinely strengthens it
+        while honestly bounding where it holds. The fortification reinforces
+        the position by sharpening it.
+
+    ...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/>:
+
+    <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

@@ -0,0 +1,92 @@
+
+##  NAME
+
+`ase-meta-steelman` - Build the "Steelman" Argument
+
+##  SYNOPSIS
+
+`ase-meta-steelman`
+    [`--help`|`-h`]
+    [`--count`|`-c` *count*]
+    [`--rounds`|`-r` *rounds*]
+    *thesis*
+
+##  DESCRIPTION
+
+The `ase-meta-steelman` skill builds the strongest possible case
+*for* a supplied *thesis* - the constructive mirror of its adversarial
+counterpart `ase-meta-diaboli`. It applies a disciplined set of
+constructive-thinking tenets - charitable interpretation, strengthening
+the fundamentals, surfacing the enabling assumptions, supplying
+proportional evidence, seeking confirming cases, *Reductio Ad Bonum*,
+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 *count* pro-theses
+(supporting arguments) each ranked at least 7 on a 0 (weak) to 10
+(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
+    its strongest ("steelman") interpretation.
+
+##  EXAMPLES
+
+Strengthen a technology-choice claim:
+
+```text
+❯ /ase-meta-steelman HAPI is the best REST framework
+```
+
+Build the case for a design decision:
+
+```text
+❯ /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`,
+`ase-meta-quorum`.

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>] <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">
+    $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
@@ -39,20 +46,26 @@ addressing surface-level symptoms.
     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">
+    Determine the *maximum chain length* from <getopt-option-depth/>: if
+    <getopt-option-depth/> is *non-numeric* or *less than or equal to 0*,
+    use the default *5* instead.
+
+    Start with <n>1</n> (set iteration counter to one).
+    <while condition="<n/> is less than or equal to <getopt-option-depth/>">
         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.
 
         <template>
-        <ase-tpl-bullet-secondary/> **WHY <item/>**: <answer/>
+        <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 5 "Why" -- you can <break/> the iteration
-        when you already reached the root-cause.
-    </for>
+        The magic is NOT in exactly <getopt-option-depth/> "Why" -- you can <break/>
+        the iteration when you already reached the root-cause.
+        Finally, set <n/> to <n/> + 1 (increment iteration counter).
+    </while>
     </step>
 
 3.  <step id="STEP 3: Report Solution">

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

@@ -7,20 +7,27 @@
 
 `ase-meta-why`
     [`--help`|`-h`]
+    [`--depth`|`-d` *N*]
     *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. After identifying 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.
+
 *fact*:
     The observed *fact* (symptom, problem, or surprising outcome)
     whose root cause should be investigated. The skill implicitly
@@ -34,6 +41,12 @@ 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
+```
+
 ##  SEE ALSO
 
 `ase-code-analyze`, `ase-code-resolve`, `ase-arch-analyze`.

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

@@ -127,21 +127,21 @@ explicitly requested by this procedure via outputs based on a <template/>!
             -   *Drop* filler ("just", "really", "basically", "simply"),
                 pleasantries, and hedging ("I think", "maybe", "perhaps").
             -   *Use* shorter synonyms and common abbreviations.
-            -   *Use* `→` for causality and `—` for short subsequent facts.
+            -   *Use* `→` for causality and `-` for short subsequent facts.
             -   *Drop* articles ("a", "an", "the") and *replace*
                 conjunctions with short separate clauses where this
                 shortens the text without introducing ambiguity.
             -   *Re-wrap* the shortened free-text to the ~120-character-
                 per-line convention.
             -   *Merge* genuinely-redundant bullets (the same aspect
-                restated) and *drop* pure duplication — but *only* when
+                restated) and *drop* pure duplication - but *only* when
                 truly redundant; *never* lose a distinct aspect.
 
         3.  *Persona override*: this condense ruleset *always wins* for
             the plan content. This ruleset-based compression is applied
             *regardless* of the currently active session persona style.
 
-        4.  *Hard guardrail — semantics preserved EXACTLY*: condensing
+        4.  *Hard guardrail - semantics preserved EXACTLY*: condensing
             *only* shortens wording. It *MUST NOT* drop, merge (except
             truly-redundant bullets per sub-item 2), reorder, or alter
             *any* factual claim, requirement, file path, rule, or

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

package/plugin/skills/ase-task-implement/help.md

@@ -16,7 +16,7 @@ The `ase-task-implement` skill performs the *final implementation*
 of a task plan by modifying the corresponding *artifacts* with a
 complete *change set*. The plan is loaded from
 `.ase/tasks/`*id*`/plan.md`, and any optional `IMPLEMENTATION DRAFT`
-section produced by `ase-task-preflight` is used as a hint — the
+section produced by `ase-task-preflight` is used as a hint - the
 plain plan content always overrules the draft.
 
 If the task plan deliberately *omits* the `※ VERIFICATION` section