@rse/ase 0.9.3 → 0.9.5

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.3",
+    "version":                              "0.9.5",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

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

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.3",
+    "version":     "0.9.5",
     "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.3",
+    "version":     "0.9.5",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.3",
+    "version":                              "0.9.5",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

package/plugin/skills/ase-arch-analyze/SKILL.md

@@ -299,7 +299,7 @@ interface quality, quality attributes, and architecture governance.
       specification <mermaid-spec/> for a `flowchart TB` of the
       high-level component or layer structure and dispatch the rendering
       to the `ase-meta-diagram` sub-agent by calling the tool
-      `Agent(name: "ase:ase-meta-diagram", description: "Diagram Rendering",
+      `Agent(name: "ase-meta-diagram", description: "Diagram Rendering",
       subagent_type: "ase:ase-meta-diagram", prompt: <mermaid-spec/>)`,
       using its returned fenced code block verbatim. Show layers /
       slices / major components and their dependency direction.

package/plugin/skills/ase-arch-discover/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ase-arch-discover
-argument-hint: "[--help|-h] <functionality>"
+argument-hint: "[--help|-h] [--limit|-l=12] <functionality>"
 description: >
     Discover additional, third-party components (libraries/frameworks) for
     the technology stack to provide needed functionality.
@@ -16,15 +16,23 @@ allowed-tools:
 
 @${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-arch-discover">
 Discover Components
 </skill>
 
+<expand name="getopt"
+    arg1="ase-arch-discover"
+    arg2="--limit|-l=12">
+    $ARGUMENTS
+</expand>
+
 <objective>
 *Discover* additional, *third-party components* (libraries/frameworks)
 for the technology stack to *provide* the *needed functionality*
-<request>$ARGUMENTS</request>.
+<request><getopt-arguments/></request>.
 </objective>
 
 <flow>
@@ -93,13 +101,13 @@ for the technology stack to *provide* the *needed functionality*
 
         -   Based on the essential keywords <keyword-L/> (L=1-M),
             use the `ase-meta-search` skill in a subagent to *generally*
-            discover an initial set of a maximum of 12 *NPM packages*
+            discover an initial set of a maximum of <getopt-option-limit/> *NPM packages*
             <component-K/> and at least their real name <name-K/> and
             their unique package names <package-K/>.
 
-        -   Use the shell command `npm search --json --searchlimit 12
+        -   Use the shell command `npm search --json --searchlimit <getopt-option-limit/>
             "<keyword-1/>" [...] "<keyword-M/>"` to *specifically*
-            discover an additional set of a maximum of 12 *NPM packages*
+            discover an additional set of a maximum of <getopt-option-limit/> *NPM packages*
             <component-K/> and at least their unique package names
             <package-K/>, based on the essential keywords <keyword-L/>
             (L=1-M). Merge the results into the already existing result
@@ -109,14 +117,14 @@ for the technology stack to *provide* the *needed functionality*
 
         -   Based on the essential keywords <keyword-L/> (L=1-M),
             use the `ase-meta-search` skill in a subagent to *generally*
-            discover an initial set of a maximum of 12 *Maven packages*
+            discover an initial set of a maximum of <getopt-option-limit/> *Maven packages*
             <component-K/> and at least their real name <name-K/> and
             their unique Maven coordinates <package-K/> of the form
             `groupId:artifactId`.
 
-        -   Use the shell command `curl -s 'https://search.maven.org/solrsearch/select?q=<keyword-1/>+<keyword-M/>&rows=12&wt=json'`
+        -   Use the shell command `curl -s 'https://search.maven.org/solrsearch/select?q=<keyword-1/>+<keyword-M/>&rows=<getopt-option-limit/>&wt=json'`
             to *specifically* discover an additional set of a maximum
-            of 12 *Maven packages* <component-K/> and at least their
+            of <getopt-option-limit/> *Maven packages* <component-K/> and at least their
             unique Maven coordinates <package-K/> (i.e. `<g/>:<a/>` from
             each result document's `g` and `a` fields), based on the
             essential keywords <keyword-L/> (L=1-M). Merge the results
@@ -139,7 +147,7 @@ for the technology stack to *provide* the *needed functionality*
 
     -   Sort, in descending order, the discovered components
         <component-K/> (K=1-N) by their `rank` field and trim the result
-        list to just a maximum of 12 total components.
+        list to just a maximum of <getopt-option-limit/> total components.
 
     -   For each component <component-K/> (K=1-N), research and then
         decide which *one* of *USP* (Unique Selling Point -- what makes

package/plugin/skills/ase-arch-discover/help.md

@@ -7,6 +7,7 @@
 
 `ase-arch-discover`
     [`--help`|`-h`]
+    [`--limit`|`-l=12`]
     *functionality*
 
 ##  DESCRIPTION
@@ -23,6 +24,13 @@ stars, dates) via the `ase_component_info` MCP tool, and reports
 the top-ranked components as a Markdown table together with a single
 distinguishing hint (USP, Crux, or Gotcha) per component.
 
+##  OPTIONS
+
+`--limit`|`-l=12`:
+    The *maximum* number of components searched per source and retained
+    in the final ranking (default: 12). Raise it for a broader, more
+    exhaustive survey, lower it for a quicker, narrower lookup.
+
 ##  ARGUMENTS
 
 *functionality*:
@@ -43,6 +51,12 @@ Discover components for HTTP client functionality:
 ❯ /ase-arch-discover HTTP client with retries
 ```
 
+Discover a broader set of up to 20 HTTP client components:
+
+```text
+❯ /ase-arch-discover --limit 20 HTTP client with retries
+```
+
 ##  SEE ALSO
 
 `ase-arch-analyze`, `ase-meta-search`, `ase-meta-evaluate`.

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

@@ -1,8 +1,10 @@
 ---
 name: ase-code-analyze
-argument-hint: "[--help|-h] <source-reference>"
+argument-hint: "[--help|-h] [--performance|-p] [--security|-s] [--severity|-S=(LOW|MEDIUM|HIGH)] <source-reference>"
 description: >
-    Analyze the source code for problems in the logic and semantics and its related control flow.
+    Analyze the source code for problems in either the logic and
+    semantics and its related control flow, performance and efficiency,
+    or security.
 user-invocable: true
 disable-model-invocation: false
 effort: high
@@ -12,50 +14,174 @@ 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-code-analyze">
 Analyze Source Code
 </skill>
 
+<expand name="getopt"
+    arg1="ase-code-analyze"
+    arg2="--performance|-p --security|-s --severity|-S=(LOW|MEDIUM|HIGH)">
+    $ARGUMENTS
+</expand>
+
 <objective>
-*Analyze* the source code of $ARGUMENTS, and its directly related source
-code, for problems in its *logic* and *semantics* and its related
-*control flow*.
+*Analyze* the source code of <getopt-arguments/>, and its directly
+related source code, for problems - read-only, *without* applying any
+changes. The *analysis lens* depends on the selected options: problems
+in its *logic* and *semantics* and its related *control flow*, or
+problems in *performance* and *efficiency*, or problems in *security*.
 </objective>
 
 <flow>
 
-1.  <step id="STEP 1: Investigate Code Base">
-    In this STEP 1, investigate on the code. If the code base is large,
+1.  <step id="STEP 1: Sanity Check Usage">
+
+    <if condition="<getopt-option-performance/> is equal `true` and <getopt-option-security/> is equal `true`">
+
+    Only output the following <template/> and then *STOP* immediately:
+
+    <template>
+    ⧉ **ASE**: ✪ skill: **ase-code-analyze**, ▶ ERROR: options `--performance` and `--security` are mutually exclusive
+    </template>
+
+    </if>
+
+    </step>
+
+2.  <step id="STEP 2: Investigate Code Base">
+
+    In this STEP 2, investigate on the code. If the code base is large,
     you *MUST* use the `Agent` tool (not inline work) to create multiple
     sub-agents to split the investigation task into appropriate chunks.
 
     Tenets:
 
     -   **Quiet Operation**:
-        During investigation in this STEP 1, do *not* output anything else,
+
+        During investigation in this STEP 2, do *not* output anything else,
         especially do not give any further explanations or information.
 
     -   **Practical Relevance Only**:
+
         Focus on *practically relevant* cases and especially do *not*
         investigate theoretical or fictive cases.
 
     -   **Problem Focus Only**:
+
         Still focus on the *problem only* and do *not* already
-        investigate any possible *solution*.
+        investigate any possible *solution* or apply any *change*.
+
+    -   **Lens Focus**:
+
+        <if condition="<getopt-option-performance/> is equal `true`">
+
+        Focus on *performance* and *efficiency* only - and do *not*
+        investigate logic, semantics, control flow, or security
+        problems.
+
+        Analysis Hints (not exhaustive, just indicators):
+        -   high algorithmic complexity
+        -   needless resource allocations/copies
+        -   redundant recomputation
+        -   many I/O and query round-trips
+        -   concurrency bottlenecks
+        -   mismatched data structures
+        -   [...]
+
+        </if>
+
+        <if condition="<getopt-option-security/> is equal `true`">
+
+        Focus on *security* only - and do *not* investigate logic,
+        semantics, performance, or efficiency problems.
+
+        Analysis Hints (not exhaustive, just indicators):
+        -   unsafe data deserialization
+        -   missing input data validation/sanitization
+        -   broken authentication/authorization
+        -   sensitive-data exposure
+        -   path traversal
+        -   unsafe cryptography
+        -   hard-coded secrets
+        -   vulnerable dependencies
+        -   [...]
+
+        </if>
+
+        <if condition="<getopt-option-performance/> is NOT equal `true` and <getopt-option-security/> is NOT equal `true`">
+
+        Focus on problems in the *logic* and *semantics* and the related
+        *control flow* only - and do *not* investigate performance,
+        efficiency, or security problems.
+
+        Analysis Hints (not exhaustive, just indicators):
+        -   incorrect conditionals and boolean logic
+        -   off-by-one and boundary errors
+        -   operator misuse
+        -   mishandled edge cases
+        -   broken or missing error handling
+        -   incorrect async/await/promise handling
+        -   control-flow defects (unreachable code, missing breaks, wrong early returns)
+        -   state-mutation bugs
+        -   incorrect default values
+        -   null/undefined mishandling
+        -   type-coercion bugs
+        -   faulty parsing or merge/override semantics
+        -   [...]
+
+        </if>
+
+    You *MUST* not output anything in this STEP 2.
+
     </step>
 
-2.  <step id="STEP 2: Show Results">
-    In this STEP 2, for every detected problem, immediately report it
-    with the following output <template/>, based on concise bullet
+3.  <step id="STEP 3: Show Results">
+
+    Before reporting, *apply the severity floor* selected via
+    <getopt-option-severity/> (default `LOW`): define the ordinal rank
+    `LOW`=1, `MEDIUM`=2, `HIGH`=3. *Keep* a detected problem if and only
+    if its <severity/> is `ACCEPTED` *or* `rank(severity)` is greater
+    than or equal to `rank(<getopt-option-severity/>)`; *silently drop*
+    all other problems (they are neither reported nor persisted). With
+    the default floor `LOW`, all problems are kept. `ACCEPTED` problems
+    are *never* dropped. Then renumber the surviving problems
+    contiguously as `P<n/>` with <n/> = 1, 2, ... in the original
+    ordering. If *all* problems are dropped, skip the per-problem report
+    but still emit the final hint <template/> below.
+
+    In this STEP 3, for *EVERY* surviving problem, immediately report
+    it with the following output <template/>, based on concise bullet
     points.
 
+    <if condition="<getopt-option-performance/> is equal `true`">
+
     <template>
-    <ase-tpl-bullet-signal/> PROBLEM (Severity: **<severity/>**): **P<n/>**: **<title/>**
+
+    <ase-tpl-bullet-signal/> **PROBLEM** (Severity: **<severity/>**): **P<n/>**: **<title/>**
+
+    <description/>
+
+    ⊙ EVIDENCE: <evidence/>
+    ⊖ TRADEOFF: <trade-off/>
+
+    </template>
+
+    </if>
+
+    <if condition="<getopt-option-performance/> is NOT equal `true`">
+
+    <template>
+
+    <ase-tpl-bullet-signal/> **PROBLEM** (Severity: **<severity/>**): **P<n/>**: **<title/>**
 
     <description/>
+
     </template>
 
+    </if>
+
     Hints:
 
     -   For the final results, do *not* output anything else, especially do
@@ -77,7 +203,23 @@ code, for problems in its *logic* and *semantics* and its related
 
     -   In <description/>, classify the problem with a <severity/>
         of <template>LOW</template>, <template>MEDIUM</template> or
-        <template>HIGH</template>.
+        <template>HIGH</template>, ranked by the estimated *impact* of the
+        problem.
+
+    -   <if condition="<getopt-option-performance/> is equal `true`">
+        In <evidence/>, ground the finding by citing either the inferred
+        *Big-O* time/space complexity (e.g. `O(n²)` reducible to `O(n)`)
+        with the exact driving loop or recursion, or the matched
+        performance *anti-pattern* (e.g. N+1 query, sync-in-loop, repeated
+        recompute, string concat in loop), with an inline code reference.
+        </if>
+
+    -   <if condition="<getopt-option-performance/> is equal `true`">
+        In <trade-off/>, state the *cost* of the optimization (e.g.
+        readability, additional memory for speed, added complexity), so
+        the user can make an informed decision; use *none* if there is no
+        meaningful trade-off.
+        </if>
 
     -   *Additionally*, persist all reported problems in a *single*
         `ase_kv_batch` call to the `ase` MCP server with `transactional`
@@ -85,17 +227,19 @@ code, for problems in its *logic* and *semantics* and its related
         starts with one `{ command: "clear" }` entry, followed by one
         `{ command: "set", key: "ase-issue-P<n/>", val: "<title/>:
         <description/>" }` entry per reported problem.
-    </step>
 
-3.  <step id="STEP 3: Give Final Hint">
-    Finally, in this STEP 3, output the following <template/> to give a
-    final hint:
+    Finally, output the following <template/> to give a final hint:
 
     <template>
     ⧉ **ASE**: ☻ skill: **<skill-name/>**, ▶ status: **skill finished**
     ⧉ **ASE**: ↪ hint: **For deeper analysis, suggestions on solution approaches and then final problem resolution, use `/ase-code-resolve P{n}` in the same or even a different session.**
     </template>
+
+    You *MUST* not output anything else in this STEP 3,
+    especially not any further explanations.
+
     </step>
 
 </flow>
 
+</output>

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

@@ -7,19 +7,41 @@
 
 `ase-code-analyze`
     [`--help`|`-h`]
+    [`--performance`|`-p`]
+    [`--security`|`-s`]
+    [`--severity`|`-S`=(`LOW`|`MEDIUM`|`HIGH`)]
     *source-reference*
 
 ##  DESCRIPTION
 
 The `ase-code-analyze` skill analyzes the source code of the referenced
-location, and its directly related source code, for problems in its
-*logic*, *semantics*, and related *control flow*.
+location, and its directly related source code, for problems. It is
+*read-only* and advisory: it reports problems but applies *no* changes.
+
+The *analysis lens* depends on the selected options:
+
+- **default** (neither `--performance` nor `--security`): problems in
+  its *logic*, *semantics*, and related *control flow*.
+
+- `--performance`|`-p`: problems in *performance* and *efficiency*.
+
+- `--security`|`-s`: problems in *security*.
+
+The `--performance` and `--security` options are *mutually exclusive*.
+
+The `--severity`|`-S`=(`LOW`|`MEDIUM`|`HIGH`) option sets a *severity
+floor* (default `LOW`): problems below the chosen threshold are silently
+suppressed (neither reported nor persisted), ordered `LOW` < `MEDIUM` <
+`HIGH`. The default `LOW` keeps all problems; `ACCEPTED` problems are
+never suppressed. Surviving problems are renumbered contiguously as
+`P<n>`.
 
 The skill investigates the code base silently, reports each detected
-problem as a `PROBLEM` entry with severity (`LOW`, `MEDIUM`, `HIGH`),
-inline file/line references, and persists results in the `ase` MCP
-key/value store as `ase-issue-P<n>` entries so they can later be
-resolved via `ase-code-resolve P<n>`.
+problem as a `PROBLEM` entry with severity (`LOW`, `MEDIUM`, `HIGH`) and
+inline file/line references (in the performance lens, each entry
+additionally carries an *evidence* and a *trade-off* line), and persists
+results in the `ase` MCP key/value store as `ase-issue-P<n>` entries so
+they can later be resolved via `ase-code-resolve P<n>`.
 
 ##  ARGUMENTS
 
@@ -29,7 +51,7 @@ resolved via `ase-code-resolve P<n>`.
 
 ##  EXAMPLES
 
-Analyze a specific source file:
+Analyze a specific source file for logic/semantic problems:
 
 ```text
 ❯ /ase-code-analyze src/server.ts
@@ -41,6 +63,24 @@ Analyze a directory of code:
 ❯ /ase-code-analyze src/handlers/
 ```
 
+Analyze a source file for performance/efficiency opportunities only:
+
+```text
+❯ /ase-code-analyze --performance src/server.ts
+```
+
+Analyze a source file for security aspects only:
+
+```text
+❯ /ase-code-analyze -s src/handlers/
+```
+
+Analyze a directory, reporting only `MEDIUM` and `HIGH` problems:
+
+```text
+❯ /ase-code-analyze -S MEDIUM src/handlers/
+```
+
 ##  SEE ALSO
 
 `ase-code-resolve`, `ase-code-refactor`, `ase-code-lint`,

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

@@ -228,7 +228,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             TB`, `stateDiagram-v2`, `sequenceDiagram`, `classDiagram`,
             or `erDiagram`, depending on intent) and dispatching the
             rendering to the `ase-meta-diagram` sub-agent by calling
-            the tool `Agent(name: "ase:ase-meta-diagram", description:
+            the tool `Agent(name: "ase-meta-diagram", description:
             "Diagram Rendering", subagent_type: "ase:ase-meta-diagram",
             prompt: <mermaid-spec/>)`, reproducing its returned fenced
             code block verbatim. For *current vs. proposed* comparisons,

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

@@ -89,7 +89,7 @@ Give *insights* into the project through the source code of $ARGUMENTS.
     <mermaid-spec/> for a `flowchart TB` diagram with all modules as
     boxes and the imports between modules as the directed edges. Then
     dispatch the rendering to the `ase-meta-diagram` sub-agent by
-    calling the tool `Agent(name: "ase:ase-meta-diagram", description:
+    calling the tool `Agent(name: "ase-meta-diagram", description:
     "Diagram Rendering", subagent_type: "ase:ase-meta-diagram", prompt:
     <mermaid-spec/>)` and reproduce its returned fenced code block
     verbatim in the response text. Do not display any further

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

@@ -1,6 +1,6 @@
 ---
 name: ase-code-lint
-argument-hint: "[--help|-h] [--auto|-a] <source-reference>"
+argument-hint: "[--help|-h] [--auto|-a] [--severity|-S=(LOW|MEDIUM|HIGH)] <source-reference>"
 description: >
     Lint source code for potential code quality problems.
     Use when the user wants to "lint" or "check" source code.
@@ -20,7 +20,7 @@ Lint Source Code
 
 <expand name="getopt"
     arg1="ase-code-lint"
-    arg2="--auto|-a">
+    arg2="--auto|-a --severity|-S=(LOW|MEDIUM|HIGH)">
     $ARGUMENTS
 </expand>
 
@@ -48,7 +48,7 @@ related to a set of code quality aspects.
 
     ```text
         Agent(
-            name:          "ase:ase-code-lint",
+            name:          "ase-code-lint",
             description:   "Lint Investigation",
             subagent_type: "ase:ase-code-lint",
             mode:          "plan",
@@ -59,6 +59,14 @@ related to a set of code quality aspects.
     Parse the single result message of the `Agent` tool as a JSON array
     and set <problems/> to that list.
 
+    Then *apply the severity floor* selected via <getopt-option-severity/>
+    (default `LOW`): define the ordinal rank `LOW`=1, `MEDIUM`=2,
+    `HIGH`=3. *Keep* a problem in <problems/> if and only if its
+    `severity` field is `ACCEPTED` *or* `rank(severity)` is greater than
+    or equal to `rank(<getopt-option-severity/>)`; *silently drop* all
+    other problems. With the default floor `LOW`, all problems are kept.
+    `ACCEPTED` problems are *never* dropped.
+
     You *MUST* *NOT* output anything else in this step 1.
 
     </step>

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

@@ -8,6 +8,7 @@
 `ase-code-lint`
     [`--help`|`-h`]
     [`--auto`|`-a`]
+    [`--severity`|`-S`=(`LOW`|`MEDIUM`|`HIGH`)]
     *source-reference*
 
 ##  DESCRIPTION
@@ -29,6 +30,12 @@ automatically.
     Automatically apply every proposed correction without asking the
     user via the interactive dialog.
 
+`--severity`|`-S`=(`LOW`|`MEDIUM`|`HIGH`):
+    Set the *severity floor* (default `LOW`): findings below the chosen
+    threshold are silently suppressed, ordered `LOW` < `MEDIUM` <
+    `HIGH`. The default `LOW` keeps all findings; `ACCEPTED` findings are
+    never suppressed.
+
 ##  ARGUMENTS
 
 *source-reference*:
@@ -48,6 +55,12 @@ Lint a directory and automatically apply all corrections:
 ❯ /ase-code-lint --auto src/handlers/
 ```
 
+Lint a directory, reporting only `MEDIUM` and `HIGH` findings:
+
+```text
+❯ /ase-code-lint -S MEDIUM src/handlers/
+```
+
 ##  SEE ALSO
 
 `ase-code-analyze`, `ase-code-resolve`, `ase-code-refactor`,

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

@@ -218,7 +218,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             (e.g. `flowchart TB`, `stateDiagram-v2`, `sequenceDiagram`,
             `classDiagram`, or `erDiagram`, depending on intent) and
             dispatching the rendering to the `ase-meta-diagram`
-            sub-agent by calling the tool `Agent(name: "ase:ase-meta-diagram",
+            sub-agent by calling the tool `Agent(name: "ase-meta-diagram",
             description: "Diagram Rendering", subagent_type:
             "ase:ase-meta-diagram", prompt: <mermaid-spec/>)`, reproducing
             its returned fenced code block verbatim. For *current

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

@@ -154,7 +154,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
           TB`, `stateDiagram-v2`, `sequenceDiagram`, `classDiagram`, or
           `erDiagram`, depending on intent) and dispatching the rendering
           to the `ase-meta-diagram` sub-agent by calling the tool
-          `Agent(name: "ase:ase-meta-diagram", description: "Diagram
+          `Agent(name: "ase-meta-diagram", description: "Diagram
           Rendering", subagent_type: "ase:ase-meta-diagram", prompt:
           <mermaid-spec/>)`, reproducing its returned fenced code block
           verbatim. Omit <optional-diagram/> entirely for simple or
@@ -267,7 +267,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             (e.g. `flowchart TB`, `stateDiagram-v2`, `sequenceDiagram`,
             `classDiagram`, or `erDiagram`, depending on intent) and
             dispatching the rendering to the `ase-meta-diagram`
-            sub-agent by calling the tool `Agent(name: "ase:ase-meta-diagram",
+            sub-agent by calling the tool `Agent(name: "ase-meta-diagram",
             description: "Diagram Rendering", subagent_type:
             "ase:ase-meta-diagram", prompt: <mermaid-spec/>)`, reproducing
             its returned fenced code block verbatim. For *current

package/plugin/skills/ase-docs-distill/SKILL.md

@@ -109,7 +109,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
             where `Ls` is the start line and `Le` is the end line.
 
         -   A *verbatim* <evidence/> snippet, copied exactly from
-            <source/> (but with all newlines replaces with spaces
+            <source/> (but with all newlines replaced with spaces
             and multiple spaces collapsed into a single space), that
             *proves* the point. The cited snippet *MUST* prove the
             point verbatim. If it does not, *re-investigate and re-cite

package/plugin/skills/ase-docs-proofread/SKILL.md

@@ -48,7 +48,7 @@ Analyze documents for spelling, punctuation, or grammar errors
 
     ```text
         Agent(
-            name:          "ase:ase-docs-proofread",
+            name:          "ase-docs-proofread",
             description:   "Proofread Investigation",
             subagent_type: "ase:ase-docs-proofread",
             mode:          "plan",