@rse/ase 0.9.45 → 0.9.46

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.45",
+    "version":                              "0.9.46",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -42,12 +42,12 @@
     },
     "dependencies": {
         "commander":                        "15.0.0",
-        "@dotenvx/dotenvx":                 "2.15.1",
+        "@dotenvx/dotenvx":                 "2.17.2",
         "yaml":                             "2.9.0",
         "valibot":                          "1.4.2",
         "execa":                            "10.0.0",
         "mkdirp":                           "3.0.1",
-        "@hapi/hapi":                       "21.4.9",
+        "@hapi/hapi":                       "21.4.10",
         "beautiful-mermaid":                "1.1.3",
         "cli-table3":                       "0.6.5",
         "chalk":                            "5.6.2",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.45",
+    "version":     "0.9.46",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.45",
+    "version":     "0.9.46",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.github/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.45",
+    "version":     "0.9.46",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/etc/stx.conf

@@ -11,7 +11,12 @@ lint
 
 #   [plugin] build project
 build : lint
-    true
+    (   for name in $(cd skills; ls -1 | grep -v ase-meta-intent | sort); do
+            echo "<skill name=\"$name\">"
+            cat skills/$name/help.md | sed -e '/^##  SEE ALSO/,$d'
+            echo "</skill>"
+        done
+    ) >skills/ase-meta-intent/data.md
 
 #   [plugin] remove all generated files
 clean

package/plugin/meta/ase-dialog.md

@@ -50,7 +50,7 @@ following procedure:
         excluding the question label on line 1, and stopping at the first missing line --
         the same lines the entry loop below renders).
 
-        <for items="2 3 4 5 6 7 8 9">
+        <for items="2 3 4 5 6 7 8 9 10">
             Take from <spec/> the line number <item/>.
             If this line does not exist, <break/>.
             If this line exists, parse it according to the format `<label/>: <description/>`.
@@ -103,7 +103,7 @@ following procedure:
         </text>
 
         If <n/> is less than 2:
-        Set <result>ERROR: custom-dialog requires 2-8 answer lines, got <n/></result>
+        Set <result>ERROR: custom-dialog requires 2-9 answer lines, got <n/></result>
         and *SKIP* the following step 2.2 and continue with step 2.3 dispatch.
 
     2.  Output the following <template/>, end the current turn, wait for the

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.45",
+    "version":                              "0.9.46",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

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

@@ -23,7 +23,7 @@ Craft Source Code
 
 <expand name="getopt"
     arg1="ase-code-craft"
-    arg2="--auto|-a --dry|-d --quick|-Q --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)...">
+    arg2="--auto|-a --dry|-d --quick|-Q --next|-n=(none|DONE|EDIT|GRILL|PREFLIGHT|IMPLEMENT)...">
     $ARGUMENTS
 </expand>
 
@@ -303,7 +303,21 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </elseif>
 
-        4.  <else>
+        4.  <elseif condition="<head/> is equal `GRILL`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). `GRILL`
+            is this skill's own dispatch token, *not* part of
+            `ase-task-grill`'s `--next` vocabulary, so it must be
+            stripped here rather than forwarded. All remaining tokens are
+            `ase-task-grill`'s own vocabulary and are forwarded verbatim.
+            <if condition="<getopt-option-next/> is not equal `none`">
+                Set <args><args/> --next <getopt-option-next/></args>
+            </if>
+            Call the tool `Skill(skill: "ase:ase-task-grill", args: "<args/>")`
+            to *grill* the freshly composed plan, bypassing `ase-task-edit`.
+            </elseif>
+
+        5.  <else>
             Hand off to `ase-task-edit`.
             <if condition="<head/> is equal `EDIT`">
                 Consume the head: set <getopt-option-next/> to the remaining

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

@@ -50,15 +50,16 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
 `--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
+    list* of tokens; an `IMPLEMENT`, `PREFLIGHT`, or `GRILL` 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`),
+    `ase-task-edit`), `GRILL` (hand off to `ase-task-grill`),
+    `PREFLIGHT` (hand off to `ase-task-preflight`),
     or `IMPLEMENT` (hand off to `ase-task-implement`). Example:
     `--next PREFLIGHT,IMPLEMENT,DONE` crafts the plan, preflights it,
     implements it, and exits without further dialog.
@@ -87,4 +88,4 @@ Craft a feature under a named task and directly hand off to implementation:
 ##  SEE ALSO
 
 [`ase-code-refactor`](../ase-code-refactor/help.md), [`ase-code-resolve`](../ase-code-resolve/help.md), [`ase-task-edit`](../ase-task-edit/help.md),
-[`ase-task-preflight`](../ase-task-preflight/help.md), [`ase-task-implement`](../ase-task-implement/help.md).
+[`ase-task-grill`](../ase-task-grill/help.md), [`ase-task-preflight`](../ase-task-preflight/help.md), [`ase-task-implement`](../ase-task-implement/help.md).

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

@@ -23,7 +23,7 @@ Refactor Source Code
 
 <expand name="getopt"
     arg1="ase-code-refactor"
-    arg2="--auto|-a --dry|-d --quick|-Q --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)...">
+    arg2="--auto|-a --dry|-d --quick|-Q --next|-n=(none|DONE|EDIT|GRILL|PREFLIGHT|IMPLEMENT)...">
     $ARGUMENTS
 </expand>
 
@@ -303,7 +303,21 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </elseif>
 
-        4.  <else>
+        4.  <elseif condition="<head/> is equal `GRILL`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). `GRILL`
+            is this skill's own dispatch token, *not* part of
+            `ase-task-grill`'s `--next` vocabulary, so it must be
+            stripped here rather than forwarded. All remaining tokens are
+            `ase-task-grill`'s own vocabulary and are forwarded verbatim.
+            <if condition="<getopt-option-next/> is not equal `none`">
+                Set <args><args/> --next <getopt-option-next/></args>
+            </if>
+            Call the tool `Skill(skill: "ase:ase-task-grill", args: "<args/>")`
+            to *grill* the freshly composed plan, bypassing `ase-task-edit`.
+            </elseif>
+
+        5.  <else>
             Hand off to `ase-task-edit`.
             <if condition="<head/> is equal `EDIT`">
                 Consume the head: set <getopt-option-next/> to the remaining

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

@@ -50,15 +50,16 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
 `--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
+    list* of tokens; an `IMPLEMENT`, `PREFLIGHT`, or `GRILL` 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`),
+    `ase-task-edit`), `GRILL` (hand off to `ase-task-grill`),
+    `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.
@@ -87,4 +88,4 @@ Refactor under a named task and directly hand off to implementation:
 ##  SEE ALSO
 
 [`ase-code-craft`](../ase-code-craft/help.md), [`ase-code-resolve`](../ase-code-resolve/help.md), [`ase-task-edit`](../ase-task-edit/help.md),
-[`ase-task-preflight`](../ase-task-preflight/help.md), [`ase-task-implement`](../ase-task-implement/help.md).
+[`ase-task-grill`](../ase-task-grill/help.md), [`ase-task-preflight`](../ase-task-preflight/help.md), [`ase-task-implement`](../ase-task-implement/help.md).

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

@@ -23,7 +23,7 @@ Resolve Problem
 
 <expand name="getopt"
     arg1="ase-code-resolve"
-    arg2="--auto|-a --dry|-d --quick|-Q --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)...">
+    arg2="--auto|-a --dry|-d --quick|-Q --next|-n=(none|DONE|EDIT|GRILL|PREFLIGHT|IMPLEMENT)...">
     $ARGUMENTS
 </expand>
 
@@ -364,7 +364,21 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </elseif>
 
-        4.  <else>
+        4.  <elseif condition="<head/> is equal `GRILL`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). `GRILL`
+            is this skill's own dispatch token, *not* part of
+            `ase-task-grill`'s `--next` vocabulary, so it must be
+            stripped here rather than forwarded. All remaining tokens are
+            `ase-task-grill`'s own vocabulary and are forwarded verbatim.
+            <if condition="<getopt-option-next/> is not equal `none`">
+                Set <args><args/> --next <getopt-option-next/></args>
+            </if>
+            Call the tool `Skill(skill: "ase:ase-task-grill", args: "<args/>")`
+            to *grill* the freshly composed plan, bypassing `ase-task-edit`.
+            </elseif>
+
+        5.  <else>
             Hand off to `ase-task-edit`.
             <if condition="<head/> is equal `EDIT`">
                 Consume the head: set <getopt-option-next/> to the remaining

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

@@ -55,15 +55,16 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
 `--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
+    list* of tokens; an `IMPLEMENT`, `PREFLIGHT`, or `GRILL` 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`),
+    `ase-task-edit`), `GRILL` (hand off to `ase-task-grill`),
+    `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.
@@ -93,5 +94,5 @@ Resolve a previously analyzed issue and hand off to implementation:
 ##  SEE ALSO
 
 [`ase-code-craft`](../ase-code-craft/help.md), [`ase-code-refactor`](../ase-code-refactor/help.md), [`ase-code-analyze`](../ase-code-analyze/help.md),
-[`ase-arch-analyze`](../ase-arch-analyze/help.md), [`ase-task-edit`](../ase-task-edit/help.md), [`ase-task-preflight`](../ase-task-preflight/help.md),
-[`ase-task-implement`](../ase-task-implement/help.md).
+[`ase-arch-analyze`](../ase-arch-analyze/help.md), [`ase-task-edit`](../ase-task-edit/help.md), [`ase-task-grill`](../ase-task-grill/help.md),
+[`ase-task-preflight`](../ase-task-preflight/help.md), [`ase-task-implement`](../ase-task-implement/help.md).

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

@@ -0,0 +1,116 @@
+---
+name: ase-meta-eli5
+argument-hint: "[--help|-h] [--ground|-g] <topic>"
+description: >
+    Explain a topic in "Explain Like I'm 5" (ELI5) style, optionally
+    grounded in Internet/Web facts. Use when the user wants a topic
+    explained in a very simple, child-friendly way, or mentions "eli5"
+    or "explain like I'm 5".
+user-invocable: true
+disable-model-invocation: false
+effort: high
+allowed-tools:
+    - "Agent"
+---
+
+@${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-eli5">
+Explain a Topic Like I'm 5
+</skill>
+
+<expand name="getopt"
+    arg1="ase-meta-eli5"
+    arg2="--ground|-g">
+    $ARGUMENTS
+</expand>
+
+<objective>
+*Explain* the following topic in "Explain Like I'm 5" (ELI5) style,
+so that even a five year old child could understand it:
+<topic><getopt-arguments/></topic>
+</objective>
+
+<flow>
+
+1.  <step id="STEP 1: Check Topic">
+
+    <if condition="<topic/> is empty">
+    Only output the following <template/> and then immediately *STOP*
+    processing the entire current skill:
+
+    <template>
+    ⧉ **ASE**: ✪ skill: **ase-meta-eli5**, ▶ ERROR: expected a `<topic>` argument
+    </template>
+    </if>
+
+    Set <facts></facts> (set to empty)
+
+    </step>
+
+2.  <step id="STEP 2: Ground Topic" condition="<getopt-option-ground/> is equal `true`">
+
+    Use the `ase-meta-search` skill in a sub-agent to gather facts
+    about the <topic/>: call the tool...
+
+    `Agent(
+        description: "Query Web Search Service",
+        subagent_type: "ase:ase-meta-search",
+        prompt: "Search the Internet/Web and gather facts about the following topic: <topic/>",
+        run_in_background: false
+    )`
+
+    ...and store the returned facts in <facts/>.
+
+    <if condition="<facts/> contains no usable facts about <topic/>">
+
+    Set <facts></facts> (set facts to empty), so the explanation below
+    falls back to model knowledge, and output the following <template/>:
+
+    <template>
+    <ase-tpl-bullet-secondary/> **WARNING**: grounding found no usable facts -- falling back to model knowledge.
+    </template>
+
+    </if>
+
+    </step>
+
+3.  <step id="STEP 3: Explain Topic">
+
+    Explain the <topic/> in "Explain Like I'm 5" (ELI5) style: use
+    *simple*, *jargon-free* wording a five year old child could
+    understand -- short sentences, everyday words, and familiar images.
+    Do *not* use technical terms without immediately putting them into
+    child-friendly words.
+
+    <if condition="<facts/> is not empty">
+    Ground the explanation in the facts of <facts/> and do not
+    contradict them.
+    </if>
+
+    For this, first, explain *WHAT* the topic is and store it in
+    <what/>. Second, give an *ANALOGY* by comparing the topic to
+    something from the everyday life of a child and store this in
+    <analogy/>. Third, explain *WHY* the topic matters and store this in
+    <why/>.
+
+    Ensure that each of <what/>, <analogy/>, and <why/> is a *very
+    brief* and *concise* single text paragraph.
+
+    Output the result with the following <template/>:
+
+    <template>
+    <ase-tpl-bullet-secondary/> **TOPIC**: **<topic/>**
+
+    <ase-tpl-bullet-normal/> **WHAT**: <what/>.
+
+    <ase-tpl-bullet-normal/> **ANALOGY**: <analogy/>.
+
+    <ase-tpl-bullet-signal/> **WHY**: <why/>.
+    </template>
+
+    </step>
+
+</flow>

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

@@ -0,0 +1,61 @@
+
+##  NAME
+
+`ase-meta-eli5` - Explain a Topic Like I'm 5
+
+##  SYNOPSIS
+
+`ase-meta-eli5`
+    [`--help`|`-h`]
+    [`--ground`|`-g`]
+    *topic*
+
+##  DESCRIPTION
+
+The `ase-meta-eli5` skill explains the supplied *topic* in "Explain
+Like I'm 5" (ELI5) style, so that even a five year old child could
+understand it. The explanation uses simple, jargon-free wording --
+short sentences, everyday words, and familiar images -- and is
+structured into three labeled blocks: *WHAT* (a plain-words summary),
+*ANALOGY* (a concrete everyday-life comparison), and *WHY* (why the
+topic matters), each kept brief with 1-3 bullet points.
+
+By default the explanation is derived from model knowledge only. With
+the `--ground`/`-g` option, the skill first searches the Internet/Web
+for facts about the topic via the `ase-meta-search` skill (dispatched
+in a sub-agent, querying all available search backends) and grounds
+the explanation in the found facts. If the grounding yields no usable
+facts, a warning is emitted and the explanation falls back to model
+knowledge.
+
+##  OPTIONS
+
+`--ground`|`-g`:
+    Ground the explanation in Internet/Web facts gathered via the
+    `ase-meta-search` skill before explaining. Without this option,
+    the explanation is derived from model knowledge only.
+
+##  ARGUMENTS
+
+*topic*:
+    The topic to be explained. It may be a technical concept, a
+    phenomenon, or any other subject; the skill explains it in a
+    child-friendly way.
+
+##  EXAMPLES
+
+Explain a technical concept from model knowledge:
+
+```text
+❯ /ase-meta-eli5 What is a Fourier transform?
+```
+
+Explain a recent topic grounded in Internet/Web facts:
+
+```text
+❯ /ase-meta-eli5 --ground What is Agentic Software Engineering?
+```
+
+##  SEE ALSO
+
+[`ase-code-explain`](../ase-code-explain/help.md), [`ase-meta-search`](../ase-meta-search/help.md), [`ase-docs-distill`](../ase-docs-distill/help.md).

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

@@ -0,0 +1,157 @@
+---
+name: ase-meta-intent
+argument-hint: "[--help|-h] <intent>"
+description: >
+    Match a free-text intent against the accumulated help of all ASE
+    skills, generate the single best-fitting `/ase:ase-xxx-xxx` command
+    with concrete options and arguments, and let the user execute it,
+    refine the intent, or cancel. Use when the user knows what they want
+    but not which skill or flags realize it, or mentions "intent" or
+    requests "help".
+user-invocable: true
+disable-model-invocation: false
+effort: high
+allowed-tools:
+    - "Skill"
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
+
+<skill name="ase-meta-intent">
+Match an Intent to an ASE Command
+</skill>
+
+<expand name="getopt"
+    arg1="ase-meta-intent"
+    arg2="">
+    $ARGUMENTS
+</expand>
+
+<objective>
+*Match* the following free-text intent against the accumulated help of
+all ASE skills and *generate* the single best-fitting `/ase:ase-xxx-xxx`
+command that realizes it:
+<intent><getopt-arguments/></intent>
+</objective>
+
+The following <corpus/> is the *accumulated help* of all ASE skills --
+the concatenation of every skill's `help.md` file -- and is the *sole*
+catalog you match <intent/> against:
+
+<corpus>
+@${CLAUDE_SKILL_DIR}/data.md
+</corpus>
+
+<flow>
+
+1.  <step id="STEP 1: Check Intent">
+
+    <if condition="<intent/> is empty">
+    Only output the following <template/> and then immediately *STOP*
+    processing the entire current skill:
+
+    <template>
+    ⧉ **ASE**: ✪ skill: **ase-meta-intent**, ▶ ERROR: expected a `<intent>` argument
+    </template>
+    </if>
+
+    </step>
+
+2.  <step id="STEP 2: Match Intent and Dialog">
+
+    *REPEAT* the following sub-steps in a *LOOP* until the user either
+    *executes* the generated command or *cancels* the dialog in sub-step 4:
+
+    1.  *Match Intent*:
+
+        Match the current <intent/> against the <corpus/> and select the
+        *single* best-fitting skill. From that skill's `##  SYNOPSIS`,
+        `##  OPTIONS`, and `##  ARGUMENTS` sections in <corpus/>,
+        *generate* a concrete command that realizes <intent/>:
+
+        -   Set <name/> to the selected skill's name (e.g. `ase-code-lint`).
+        -   Set <arguments/> to the concrete option flags and positional
+            arguments -- derived from the skill's `##  OPTIONS` and
+            `##  ARGUMENTS` -- that best realize <intent/> (may be empty).
+        -   Set <command>/ase:<name/> <arguments/></command> (the full
+            command line, with surplus inner spaces collapsed).
+        -   Set <rationale/> to a *very brief*, single-sentence
+            justification of why the selected skill and its options match
+            <intent/>.
+
+    2.  *Guard No Match*:
+
+        <if condition="no skill in <corpus/> adequately matches <intent/>">
+        Output the following <template/> and then *continue* the *loop*
+        at sub-step 4 to prompt the user for a refined or clearer intent
+        via the dialog's free-text channel (do *not* stop and do *not*
+        render a command):
+
+        <template>
+        <ase-tpl-bullet-secondary/> **WARNING**: no confident match for the intent -- please refine or clarify it.
+        </template>
+        </if>
+
+    3.  *Render Command*:
+
+        Output the generated command with the following <template/>:
+
+        <template>
+        <ase-tpl-head title="SKILL COMMAND PROPOSAL"/>
+
+        ●   **INTENT**:
+        ○   <intent/>
+
+        ●   **COMMAND**:
+        ⌘   `<command/>`
+
+        ●   **RATIONALE**:
+        ○   <rationale/>
+
+        <ase-tpl-foot title="SKILL COMMAND PROPOSAL"/>
+        </template>
+
+    4.  *Dispatch Command*:
+
+        In the following, you *MUST* *NOT* use your built-in
+        <user-dialog-tool/> tool! Instead, you *MUST* just show a custom
+        dialog according to the expanded `custom-dialog` definition. You
+        *MUST* closely follow this definition.
+
+        Let the user decide what to do with the generated command by
+        raising a question with the following custom dialog (invoked with
+        `--other`, so that any free-text instruction is accepted as an
+        intent refinement):
+
+        <expand name="custom-dialog" arg1="--other">
+            Dispatch: What would you like to do with the generated command?
+            EXECUTE: Execute the generated command now.
+            CANCEL:  Cancel this dialog.
+        </expand>
+
+        Check the tool <result/> and dispatch accordingly:
+
+        -   If <result/> is `CANCEL`:
+            *Break* out of the *loop* and stop processing without any
+            further output.
+
+        -   If <result/> is `EXECUTE`:
+            *Break* out of the *loop*, output the following <template/>,
+            and then call the tool `Skill(skill: "ase:<name/>", args:
+            "<arguments/>")` to *execute* the generated command:
+
+            <template>
+            ⧉ **ASE**: ◉ intent: **<intent/>**, ⌘ command: **<command/>**, ▶ status: **command executing**
+            </template>
+
+        -   If <result/> matches `OTHER: <text/>`:
+            Set <intent><intent/> <text/></intent> (fold the free-text
+            instruction into the intent). Then you *MUST* *continue* the
+            *loop* at sub-step **2.1** to re-match the refined intent.
+
+    </step>
+
+</flow>

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

@@ -0,0 +1,56 @@
+
+##  NAME
+
+`ase-meta-intent` - Match an Intent to an ASE Command
+
+##  SYNOPSIS
+
+`ase-meta-intent`
+    [`--help`|`-h`]
+    *intent*
+
+##  DESCRIPTION
+
+The `ase-meta-intent` skill matches a free-text *intent* against the
+*accumulated help* of all ASE skills -- the concatenation of every
+skill's `help.md` file into `skills/ase-meta-intent/data.md`, built by
+`npm start build` in `plugin/` -- and generates the *single* best-fitting
+`/ase:ase-xxx-xxx` command that realizes the intent, complete with
+concrete option flags and positional arguments derived from the selected
+skill's `SYNOPSIS`, `OPTIONS`, and `ARGUMENTS`.
+
+The generated command is presented together with a brief rationale in an
+interactive dialog. The dialog lets the user *execute* the command (which
+dispatches the target skill via its generated arguments), *cancel* the
+operation, or *refine* the intent by typing any free-text instruction --
+the instruction is folded into the intent and the best-fitting command is
+re-matched and re-rendered. If no skill confidently matches the intent, a
+warning is emitted and the user is prompted to refine or clarify it.
+
+The skill exposes *no* option flags beyond `--help`/`-h`; it is driven
+entirely through the intent argument and the interactive dialog.
+
+##  ARGUMENTS
+
+*intent*:
+    The free-text intent to be realized. It describes *what* the user
+    wants to achieve; the skill determines *which* ASE skill and *which*
+    options and arguments realize it.
+
+##  EXAMPLES
+
+Route an intent to the matching command and pick from the dialog:
+
+```text
+❯ /ase-meta-intent lint the TypeScript sources for high-severity issues only
+```
+
+Route a planning intent to the matching command:
+
+```text
+❯ /ase-meta-intent explain how the authentication module works
+```
+
+##  SEE ALSO
+
+[`ase-meta-proximity`](../ase-meta-proximity/help.md), [`ase-meta-search`](../ase-meta-search/help.md), [`ase-code-craft`](../ase-code-craft/help.md).

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

@@ -0,0 +1,224 @@
+---
+name: ase-meta-proximity
+argument-hint: "[--help|-h] [--ground|-g] [--loop|-l] <topic>"
+description: >
+    Determine the conceptual proximity of a topic -- its parent topic,
+    its most relevant sibling topics, and its most relevant child
+    topics -- optionally grounded in Internet/Web facts and optionally
+    navigable in an interactive loop. Use when the user wants to explore
+    the conceptual neighborhood of a topic, or mentions "proximity" or
+    "related topics".
+user-invocable: true
+disable-model-invocation: false
+effort: high
+allowed-tools:
+    - "Agent"
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
+
+<skill name="ase-meta-proximity">
+Determine the Conceptual Proximity of a Topic
+</skill>
+
+<expand name="getopt"
+    arg1="ase-meta-proximity"
+    arg2="--ground|-g --loop|-l">
+    $ARGUMENTS
+</expand>
+
+<objective>
+*Determine* the *conceptual proximity* of the following topic -- its
+*parent* topic, its most relevant *sibling* topics, and its most
+relevant *child* topics:
+<topic><getopt-arguments/></topic>
+</objective>
+
+<define name="gather-facts">
+<if condition="<getopt-option-ground/> is equal `true`">
+Set <prompt>Search the Internet/Web and gather facts about
+<arg1/></prompt>.
+
+Then use the `ase-meta-search` skill in a sub-agent to gather facts with
+the following tool call and store the returned facts in the placeholder
+named `<arg2/>`:
+
+`Agent(
+    description: "Query Web Search Service",
+    subagent_type: "ase:ase-meta-search",
+    prompt: "<prompt/>",
+    run_in_background: false
+)`
+
+<if condition="the placeholder named `<arg2/>` contains no usable facts">
+Set the placeholder named `<arg2/>` to empty, so the determination below
+falls back to model knowledge, and output the following <template/>:
+
+<template>
+<ase-tpl-bullet-secondary/> **WARNING**: grounding found no usable facts -- falling back to model knowledge.
+</template>
+</if>
+</if>
+<else>
+Use the model's world knowledge and determine facts about <arg1/> and
+store those facts in the placeholder named `<arg2/>`.
+</else>
+</define>
+
+<flow>
+
+1.  <step id="STEP 1: Check Topic">
+
+    <if condition="<topic/> is empty">
+    Only output the following <template/> and then immediately *STOP*
+    processing the entire current skill:
+
+    <template>
+    ⧉ **ASE**: ✪ skill: **ase-meta-proximity**, ▶ ERROR: expected a `<topic>` argument
+    </template>
+    </if>
+
+    </step>
+
+2.  <step id="STEP 2: Explore Proximity">
+
+    *REPEAT* the following sub-steps in a *LOOP* until either
+    <getopt-option-loop/> is *not* equal `true` (then the loop runs
+    exactly *once* and stops after rendering), or the user declines/cancels
+    the dialog in sub-step 5:
+
+    1.  *Determine Topic*:
+
+        Determine the canonical name of the central *topic* which is stored
+        in <topic/>.
+
+        <expand name="gather-facts"
+            arg1="the following topic: <topic/>"
+            arg2="facts-topic"></expand>
+
+        Ground the determination of the canonical name of the topic
+        <topic/> in the facts of <facts-topic/> and do not contradict
+        them. Update <topic/> accordingly.
+
+    2.  *Determine Proximity*:
+
+        Determine the *conceptual proximity* of the current <topic/>
+        along three *dimensions*:
+
+        -   **PARENT**:
+
+            The single most relevant *parent* topic (the broader topic
+            that <topic/> is a specialization of), which will be stored
+            in <parent/>.
+
+            <expand name="gather-facts"
+                arg1="the PARENT topic (the broader topic that the given topic is a specialization of) of the following topic: <topic/>"
+                arg2="facts-parent"></expand>
+
+            Ground the determination of the canonical name of the parent
+            topic <parent/> in the facts of <facts-parent/> and do not
+            contradict them.
+
+        -   **SIBLINGS**:
+
+            The *four* most relevant *sibling* topics (topics on the
+            same level that share the same parent), which will be stored
+            in <sibling-1/> to <sibling-4/>.
+
+            <expand name="gather-facts"
+                arg1="the SIBLING topics (topics on the same level that share the same parent) of the following topic: <topic/>"
+                arg2="facts-siblings"></expand>
+
+            Ground the determination of the canonical names of the most
+            relevant sibling topics <sibling-1/> to <sibling-4/> in the
+            facts of <facts-siblings/> and do not contradict them.
+
+        -   **CHILDREN**:
+
+            The *four* most relevant *children* topics (narrower topics
+            that are specializations of <topic/>), stored in <child-1/>
+            to <child-4/>.
+
+            <expand name="gather-facts"
+                arg1="the CHILDREN topics (narrower topics that are specializations) of the following topic: <topic/>"
+                arg2="facts-children"></expand>
+
+            Ground the determination of the canonical names of the most
+            relevant children topics <child-1/> to <child-4/> in the
+            facts of <facts-children/> and do not contradict them.
+
+    3.  *Render Proximity*:
+
+        Output the result with the following <template/>, listing each
+        proximity topic under its bullet-prefixed section header.
+
+        <template>
+        <ase-tpl-head title="PROXIMITY TOPICS"/>
+
+        ●   **PARENT**:
+        ↑   <parent/>
+
+        ●   **TOPIC**:
+        ○   **<topic/>**
+
+        ●   **SIBLINGS**:
+        ⇄   <sibling-1/>
+        ⇄   <sibling-2/>
+        ⇄   <sibling-3/>
+        ⇄   <sibling-4/>
+
+        ●   **CHILDREN**:
+        ↓   <child-1/>
+        ↓   <child-2/>
+        ↓   <child-3/>
+        ↓   <child-4/>
+
+        <ase-tpl-foot title="PROXIMITY TOPICS"/>
+        </template>
+
+    4.  <if condition="<getopt-option-loop/> is not equal `true`">
+        The loop runs only once in non-interactive mode: *break* out of
+        the *loop* and stop processing without any further output.
+        </if>
+
+    5.  *Navigate Proximity*:
+
+        In the following, you *MUST* *NOT* use your built-in
+        <user-dialog-tool/> tool! Instead, you *MUST* just show a custom
+        dialog according to the expanded `custom-dialog` definition. You
+        *MUST* closely follow this definition.
+
+        Let the user pick one of the nine proximity topics to navigate
+        to by raising a question with the following custom dialog:
+
+        <expand name="custom-dialog" arg1="--no-other">
+            Navigate: Which proximity topic would you like to navigate to?
+            PARENT:    ↑ <parent/>
+            SIBLING-1: ⇄ <sibling-1/>
+            SIBLING-2: ⇄ <sibling-2/>
+            SIBLING-3: ⇄ <sibling-3/>
+            SIBLING-4: ⇄ <sibling-4/>
+            CHILD-1:   ↓ <child-1/>
+            CHILD-2:   ↓ <child-2/>
+            CHILD-3:   ↓ <child-3/>
+            CHILD-4:   ↓ <child-4/>
+        </expand>
+
+        Check the tool <result/> and dispatch accordingly:
+
+        -   If <result/> is `CANCEL`:
+            *Break* out of the *loop* and stop processing without any
+            further output.
+
+        -   Otherwise: Set <topic/> to the proximity topic corresponding
+            to the selected <result/> (the <parent/>, <sibling-K/>, or
+            <child-K/> value behind the chosen label).
+
+            Then you *MUST* *continue* the *loop* at step **2.1**.
+
+    </step>
+
+</flow>

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

@@ -0,0 +1,78 @@
+
+##  NAME
+
+`ase-meta-proximity` - Determine the Conceptual Proximity of a Topic
+
+##  SYNOPSIS
+
+`ase-meta-proximity`
+    [`--help`|`-h`]
+    [`--ground`|`-g`]
+    [`--loop`|`-l`]
+    *topic*
+
+##  DESCRIPTION
+
+The `ase-meta-proximity` skill determines the *conceptual proximity* of
+the supplied *topic* along three dimensions and reports the neighboring
+topics grouped into three labeled sections: *PARENT* (the single broader
+topic that *topic* specializes), *SIBLINGS* (the four most relevant
+topics on the same level, sharing the same parent), and *CHILDREN* (the
+four most relevant narrower topics that specialize *topic*).
+
+By default the proximity is derived from model knowledge only. With the
+`--ground`/`-g` option, the skill first searches the Internet/Web for
+facts about the topic via the `ase-meta-search` skill (dispatched in a
+sub-agent, querying all available search backends) and grounds the
+determination in the found facts.
+
+Without the `--loop`/`-l` option, the skill determines and prints the
+proximity of the given topic once and then stops. With the `--loop`/`-l`
+option, the skill instead presents the nine neighboring topics in an
+interactive dialog; selecting one of them makes it the new *current
+topic* and restarts the determination from the beginning, so the user
+can *navigate* the topic taxonomy up (parent), sideways (siblings), and
+down (children). Cancelling the dialog exits the loop. When `--loop` is
+combined with `--ground`, each newly selected topic is re-grounded via
+the `ase-meta-search` sub-agent before its proximity is re-determined.
+
+##  OPTIONS
+
+`--ground`|`-g`:
+    Ground the determination in Internet/Web facts gathered via the
+    `ase-meta-search` skill before determining the proximity. Without
+    this option, the determination is derived from model knowledge only.
+    When combined with `--loop`, every newly navigated-to topic is
+    re-grounded.
+
+`--loop`|`-l`:
+    Present the neighboring topics in an interactive dialog and, upon
+    selection, adopt the picked topic as the new current topic and
+    restart the determination. Without this option, the proximity of the
+    given topic is printed once and the skill stops.
+
+##  ARGUMENTS
+
+*topic*:
+    The topic whose conceptual proximity is to be determined. It may be
+    a technical concept, a phenomenon, or any other subject; the skill
+    determines its parent, sibling, and child topics.
+
+##  EXAMPLES
+
+Determine the proximity of a topic from model knowledge:
+
+```text
+❯ /ase-meta-proximity Fourier transform
+```
+
+Interactively navigate the conceptual neighborhood, grounded in
+Internet/Web facts:
+
+```text
+❯ /ase-meta-proximity --ground --loop Agentic Software Engineering
+```
+
+##  SEE ALSO
+
+[`ase-meta-eli5`](../ase-meta-eli5/help.md), [`ase-meta-search`](../ase-meta-search/help.md), [`ase-code-explain`](../ase-code-explain/help.md).