@rse/ase 0.9.45 → 0.9.47

package/dst/ase.js

@@ -59,12 +59,16 @@ const main = async () => {
     /*  parse program arguments  */
     await program.parseAsync(process.argv);
     /*  gracefully terminate  */
+    await log.close();
     process.exit(0);
 };
-main().catch((err) => {
-    if (err instanceof CommanderError)
+main().catch(async (err) => {
+    if (err instanceof CommanderError) {
+        await log.close();
         process.exit(err.exitCode);
+    }
     const message = err instanceof Error ? err.message : String(err);
     log.write("error", message);
+    await log.close();
     process.exit(1);
 });

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.47",
     "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.47",
     "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.47",
     "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.47",
     "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-help-intent | sort); do
+            echo "<skill name=\"$name\">"
+            cat skills/$name/help.md | sed -e '/^##  SEE ALSO/,$d'
+            echo "</skill>"
+        done
+    ) >skills/ase-help-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/meta/ase-skill.md

@@ -140,6 +140,15 @@ Skill Sequential Processing
 -   *IMPORTANT*: For each <step/> you *MUST* use the `TaskUpdate` tool
     for updating its status *during* processing, once a <step/> finished.
 
+-   *IMPORTANT*: Whenever a skill *stops early* -- because a <step/>
+    instructed you to *STOP* processing (on an error, a cancelled
+    dialog, a short-circuit branch, or any other early exit) -- you
+    *MUST*, *before* emitting the final <template/>, use the `TaskUpdate`
+    tool to set the status of *every* still `pending` or `in_progress`
+    task of the current <flow/> to `deleted`, so that no task of a
+    finished skill remains open. Steps that were *skipped* because their
+    `condition` attribute was not met *MUST* be treated the same way.
+
 -   *IMPORTANT*: You *MUST* *strictly sequentially* execute every <step/> in
     a <flow/>. You *MUST* not implicitly skip any <step/> during
     processing, except you were explicitly requested to do this or 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.47",
     "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-help-intent/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: ase-help-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-help-intent">
+Match an Intent to an ASE Command
+</skill>
+
+<expand name="getopt"
+    arg1="ase-help-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-help-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-help-intent/help.md

@@ -0,0 +1,57 @@
+
+##  NAME
+
+`ase-help-intent` - Match an Intent to an ASE Command
+
+##  SYNOPSIS
+
+`ase-help-intent`
+    [`--help`|`-h`]
+    *intent*
+
+##  DESCRIPTION
+
+The `ase-help-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-help-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-help-intent lint the TypeScript sources for high-severity issues only
+```
+
+Route a planning intent to the matching command:
+
+```text
+❯ /ase-help-intent explain how the authentication module works
+```
+
+##  SEE ALSO
+
+[`ase-help-skill`](../ase-help-skill/help.md), [`ase-meta-proximity`](../ase-meta-proximity/help.md), [`ase-meta-search`](../ase-meta-search/help.md),
+[`ase-code-craft`](../ase-code-craft/help.md).