@rse/ase 0.9.33 → 0.9.35

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

@@ -10,6 +10,7 @@ disable-model-invocation: false
 effort: high
 allowed-tools:
     - "Agent"
+    - "Glob"
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@@ -53,180 +54,56 @@ problems in *performance* and *efficiency*, or problems in *security*.
 
 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 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* 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
-        -   N+1 query patterns (1 parent query, N child queries)
-        -   missing caching/memoization of stable results
-        -   blocking/synchronous calls on hot paths
-        -   unbounded growth (memory leaks, ever-growing collections)
-        -   inefficient string building/concatenation in loops
-        -   premature or repeated serialization/parsing
-        -   lack of batching/pagination for bulk operations
-        -   excessive logging or instrumentation overhead
-        -   chatty network protocols (no connection pooling/keep-alive)
-        -   lock contention and overly coarse-grained locking
-        -   eager/over-fetching of data that is never used
-        -   missing database indexes
-        -   repeated regex (re)compilation in hot paths
-        -   busy-waiting/polling instead of event-driven waits
-        -   transferring uncompressed or overly verbose payloads
-        -   missing short-circuit evaluation in expensive conditions
-        -   recomputing invariants inside loops (loop-invariant code)
-        -   suboptimal batch sizes (too small = overhead, too large = latency)
-        -   inefficient algorithms for sorting/searching already-ordered data
-        -   redundant validation/sanitization of trusted internal data
-        -   missing connection/resource reuse (open-close per operation)
-        -   [...]
-
-        </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
-        -   injection flaws
-        -   cross-site scripting (XSS) and output-encoding gaps
-        -   cross-site request forgery (CSRF) and missing anti-forgery tokens
-        -   insecure direct object references (IDOR)
-        -   server-side request forgery (SSRF)
-        -   insecure or missing transport encryption (TLS)
-        -   weak session management (fixation, predictable tokens)
-        -   missing rate limiting/anti-automation controls
-        -   overly permissive CORS or file permissions
-        -   verbose error messages leaking internals
-        -   unsafe randomness for security-sensitive values
-        -   mass assignment / over-binding of request parameters
-        -   security misconfiguration (default credentials, debug modes, exposed admin endpoints)
-        -   missing or misconfigured security headers (CSP, HSTS, X-Frame-Options)
-        -   improper certificate/hostname validation (TLS verification disabled)
-        -   insufficient logging and monitoring of security events
-        -   race conditions / TOCTOU (time-of-check to time-of-use) flaws
-        -   integer overflow/underflow and buffer overflows
-        -   use-after-free and memory-safety violations
-        -   privilege escalation through improper privilege dropping
-        -   insecure file upload handling (unrestricted type/size, executable storage)
-        -   unsafe handling of untrusted regular expressions (ReDoS)
-        -   caching of sensitive data in shared or client-side caches
-        -   secrets or sensitive data leaking into logs, traces, or telemetry
-        -   insecure default-deny failures (fail-open instead of fail-closed)
-        -   missing integrity verification (unsigned updates, no subresource integrity)
-        -   excessive data exposure in API responses (returning more fields than needed)
-        -   improper resource cleanup leading to exhaustion (connection/file-descriptor leaks)
-        -   business-logic flaws (bypassable workflows, negative quantities, replay)
-        -   [...]
-
-        </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
-        -   race conditions and unsynchronized shared state
-        -   resource leaks (unclosed files, handles, connections)
-        -   inverted or swapped function arguments
-        -   incorrect loop termination or accumulator initialization
-        -   shadowed or reassigned variables changing intent
-        -   incomplete switch/case or enum coverage
-        -   silent exception swallowing
-        -   floating-point comparison and rounding errors
-        -   integer overflow/underflow or truncating division
-        -   sign and modulo errors with negative operands
-        -   reference vs. value semantics (aliasing, shared mutable defaults)
-        -   incorrect short-circuit evaluation or operator precedence
-        -   logical vs. bitwise operator confusion
-        -   negation mistakes in compound predicates
-        -   wrong comparison operator (`==` instead of `===`, `<` vs. `<=`, etc)
-        -   inverted condition or swapped if/else branches
-        -   dead or duplicated conditional branches
-        -   fall-through where a break or return was intended
-        -   missing or misplaced base case in recursion (non-termination)
-        -   mutation of a collection while iterating over it
-        -   incorrect index, key, or bounds when accessing collections
-        -   empty-collection or single-element edge cases unhandled
-        -   wrong order of operations in initialization or teardown
-        -   missing cleanup on early return, break, or exception path
-        -   double-free, use-after-free, or double-close of resources
-        -   incorrect time-zone, date arithmetic, or unit conversions
-        -   stale cache or memoization not invalidated on change
-        -   incorrect deep vs. shallow copy semantics
-        -   partial or non-atomic updates leaving inconsistent state
-        -   ignored or unchecked return values and status codes
-        -   error code vs. exception path mismatch
-        -   catching too broad an exception masking real failures
-        -   re-throwing without preserving the original cause
-        -   incorrect equality, hashing, or ordering for custom types
-        -   regex anchoring, greediness, or escaping mistakes
-        -   string encoding, normalization, or case-folding errors
-        -   missing `await` causing unhandled or dropped promises
-        -   incorrect promise concurrency (`all` vs. `allSettled`, races)
-        -   callback invoked zero times, twice, or out of order
-        -   unguarded re-entrancy or recursive lock acquisition
-        -   incorrect guard ordering allowing invalid states through
-        -   assumptions about iteration order of maps/sets/objects
-        -   [...]
-
-        </if>
-
-    You *MUST* not output anything in this STEP 2.
+    First, use the following <template/> to give a hint on this step:
+
+    <template>
+    <ase-tpl-bullet-secondary/> **ANALYSIS INVESTIGATION**
+    </template>
+
+    Dispatch the investigation to *sub-agents* via the `Agent`
+    tool so that *no* investigation details leak into the user-visible
+    transcript. The sub-agents perform the silent reading and checking;
+    only their final structured return values are consumed here.
+
+    For this, first determine the *analysis lens* <lens/>: set
+    <lens>performance</lens> if <getopt-option-performance/> is equal
+    `true`, set <lens>security</lens> if <getopt-option-security/> is
+    equal `true`, and set <lens>logic</lens> otherwise.
+
+    Then *silently* resolve `<getopt-arguments/>` to the list
+    <sources/> of individual source code files, expanding any
+    directory or wildcard references with the `Glob` tool. Then
+    partition <sources/>, preserving order, into at most *eight*
+    batches of roughly equal size (a single file yields a single
+    batch), and invoke the following tool once per batch, emitting
+    *all* invocations *in one single message* so they run in
+    *parallel*:
+
+    ```text
+        Agent(
+            description:       "Analysis Investigation (<batch-index/>/<batch-count/>)",
+            subagent_type:     "ase:ase-code-analyze",
+            prompt:            "<lens/> <batch/>",
+            run_in_background: false
+        )
+    ```
+
+    Here <batch/> is the space-separated list of the source code file
+    paths of the corresponding batch, <batch-index/> is the 1-based
+    index of that batch, and <batch-count/> is the total number of
+    batches, so that each parallel invocation is distinguishable in
+    the progress display.
+
+    Parse the result message of each `Agent` tool invocation as a JSON
+    array and concatenate all those arrays. Then *deduplicate* the
+    combined list: when two problems share the same `file` and `line`,
+    *silently drop* all but the first one (sub-agents may have read
+    overlapping *related* files for comprehension). Finally sort the
+    list by `file` and then numerically by `line`, and set <problems/>
+    to that list.
+
+    You *MUST* *NOT* output anything at all in this STEP 2 beyond the
+    `Glob` and `Agent` tool invocations.
 
     </step>
 
@@ -235,7 +112,7 @@ problems in *performance* and *efficiency*, or problems in *security*.
     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
+    if its `severity` field 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
@@ -250,9 +127,12 @@ problems in *performance* and *efficiency*, or problems in *security*.
     "ase-issue-" }` entry,
     and 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.
+    In this STEP 3, for *EVERY* surviving problem in <problems/>, set
+    <severity/> to its `severity` field, <title/> to its `title` field,
+    <description/> to its `description` field, <evidence/> to its
+    `evidence` field, and <trade-off/> to its `trade-off` field, and
+    immediately report it with the following output <template/>, based
+    on concise bullet points.
 
     <if condition="<getopt-option-performance/> is equal `true`">
 
@@ -288,45 +168,6 @@ problems in *performance* and *efficiency*, or problems in *security*.
 
     -   Uniquely identify the problems with `P<n/>` where <n/> is 1, 2, ...
 
-    -   In <description/>, use *ultra brief* but still as *precise* as
-        possible problem descriptions.
-
-    -   In <description/>, highlight *code* as <template>`<code/>`</template>
-        and *key aspects* as <template>*<aspect/>*</template>.
-
-    -   In <description/>, add inline *references* to the related
-        code positions in the form of either
-        <template>(`<filename/>:<line-number/>`)</template>,
-        <template>(`<filename/>:<line-number/>-<line-number/>`)</template> or
-        <template>(`<filename/>#<function-or-method/>`)</template>.
-
-    -   In <description/>, classify the problem with a <severity/>
-        of <template>LOW</template>, <template>MEDIUM</template>,
-        <template>HIGH</template>, or <template>ACCEPTED</template>,
-        ranked by the estimated *impact* of the problem. Use
-        <template>ACCEPTED</template> when the problem is a deliberate,
-        justified trade-off that should remain on record but is never
-        dropped by the severity floor (see STEP 3).
-
-    -   For <title/> ultra-compress the <description/> to a concise,
-        short, single sentence. Keep one inline reference to the code
-        position which is most relevant to 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`
         set to `true`. The `commands` parameter array of this call

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

@@ -74,11 +74,11 @@ code and *explain* it in a *brief*, *standardized*, and *concise* way.
     diagram type per intent: `classDiagram` for class/method structure,
     `sequenceDiagram` for actor/message flow, or `flowchart TB` for
     boxes-and-lines component layouts. Then dispatch the rendering to
-    the `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/>)` and reproduce its
-    returned fenced code block verbatim in the response text. Do *not*
-    hand-draw.
+    the `ase-meta-diagram` sub-agent by calling the tool
+    `Agent(description: "Diagram Rendering", subagent_type:
+    "ase:ase-meta-diagram", prompt: <mermaid-spec/>,
+    run_in_background: false)` and reproduce its returned fenced code
+    block verbatim in the response text. Do *not* hand-draw.
 
     Keep your explanation *brief* and *concise*.
     Output the result with the following <template/>:

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

@@ -95,11 +95,11 @@ Give *insights* into the project through the source code of <getopt-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-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
-    explanation except for this diagram.
+    calling the tool `Agent(description: "Diagram Rendering",
+    subagent_type: "ase:ase-meta-diagram", prompt: <mermaid-spec/>,
+    run_in_background: false)` and reproduce its
+    returned fenced code block verbatim in the response text. Do not
+    display any further explanation except for this diagram.
     </step>
 </flow>
 

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

@@ -39,25 +39,42 @@ related to a set of code quality aspects.
     <ase-tpl-bullet-secondary/> **LINT INVESTIGATION**
     </template>
 
-    Dispatch the investigation to a *sub-agent* via the `Agent`
+    Dispatch the investigation to *sub-agents* via the `Agent`
     tool so that *no* investigation details leak into the user-visible
-    transcript. The sub-agent performs the silent reading and checking;
-    only its final structured return value is consumed here.
-
-    For this, invoke *exactly once* the tool:
+    transcript. The sub-agents perform the silent reading and checking;
+    only their final structured return values are consumed here.
+
+    For this, first *silently* resolve `<getopt-arguments/>` to the
+    list <sources/> of individual source code files, expanding any
+    directory or wildcard references with the `Glob` tool. Then
+    partition <sources/>, preserving order, into at most *eight*
+    batches of roughly equal size (a single file yields a single
+    batch), and invoke the following tool once per batch, emitting
+    *all* invocations *in one single message* so they run in
+    *parallel*:
 
     ```text
         Agent(
-            name:          "ase-code-lint",
-            description:   "Lint Investigation",
-            subagent_type: "ase:ase-code-lint",
-            mode:          "plan",
-            prompt:        <getopt-arguments/>
+            description:       "Lint Investigation (<batch-index/>/<batch-count/>)",
+            subagent_type:     "ase:ase-code-lint",
+            prompt:            <batch/>,
+            run_in_background: false
         )
     ```
 
-    Parse the single result message of the `Agent` tool as a JSON array
-    and set <problems/> to that list.
+    Here <batch/> is the space-separated list of the source code file
+    paths of the corresponding batch, <batch-index/> is the 1-based
+    index of that batch, and <batch-count/> is the total number of
+    batches, so that each parallel invocation is distinguishable in
+    the progress display.
+
+    Parse the result message of each `Agent` tool invocation as a JSON
+    array and concatenate all those arrays. Then *deduplicate* the
+    combined list: when two problems share the same `file`, `line`, and
+    `aspect`, *silently drop* all but the first one (sub-agents may
+    have read overlapping *related* files for comprehension). Finally
+    sort the list by `file` and then numerically by `line`, 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,
@@ -260,7 +277,7 @@ related to a set of code quality aspects.
 
             <expand name="custom-dialog" arg1="--other">
                 CORRECTION: How would you like to proceed with this proposed correction?
-                ACCEPT: Apply the proposed correction.
+                ACCEPT: Apply this proposed correction.
                 REJECT: Skip this proposed correction.
             </expand>
 

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

@@ -159,11 +159,11 @@ 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-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
-          purely local situations.
+          `Agent(description: "Diagram Rendering", subagent_type:
+          "ase:ase-meta-diagram", prompt: <mermaid-spec/>,
+          run_in_background: false)`, reproducing its
+          returned fenced code block verbatim. Omit <optional-diagram/>
+          entirely for simple or purely local situations.
 
     </step>
 

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

@@ -39,28 +39,42 @@ Analyze documents for spelling, punctuation, or grammar errors
     <ase-tpl-bullet-secondary/> **PROOFREADING INVESTIGATION**
     </template>
 
-    Dispatch the investigation to a *sub-agent* via the `Agent`
+    Dispatch the investigation to *sub-agents* via the `Agent`
     tool so that *no* investigation details leak into the user-visible
-    transcript. The sub-agent performs the silent reading and checking;
-    only its final structured return value is consumed here.
-
-    For this, invoke *exactly once* the tool:
+    transcript. The sub-agents perform the silent reading and checking;
+    only their final structured return values are consumed here.
+
+    For this, first *silently* resolve `<getopt-arguments/>` to the
+    list <documents/> of individual document files, expanding any
+    directory or wildcard references with the `Glob` tool. Then
+    partition <documents/>, preserving order, into at most *eight*
+    batches of roughly equal size (a single document yields a single
+    batch), and invoke the following tool once per batch, emitting
+    *all* invocations *in one single message* so they run in
+    *parallel*:
 
     ```text
         Agent(
-            name:          "ase-docs-proofread",
-            description:   "Proofread Investigation",
-            subagent_type: "ase:ase-docs-proofread",
-            mode:          "plan",
-            prompt:        <getopt-arguments/>
+            description:       "Proofread Investigation (<batch-index/>/<batch-count/>)",
+            subagent_type:     "ase:ase-docs-proofread",
+            prompt:            <batch/>,
+            run_in_background: false
         )
     ```
 
-    Parse the single result message of the `Agent` tool as a JSON array
-    and set <problems/> to that list.
+    Here <batch/> is the space-separated list of the document file
+    paths of the corresponding batch, <batch-index/> is the 1-based
+    index of that batch, and <batch-count/> is the total number of
+    batches, so that each parallel invocation is distinguishable in
+    the progress display.
+
+    Parse the result message of each `Agent` tool invocation as a JSON
+    array, concatenate all those arrays, sort the combined list by
+    `file` and then numerically by `line`, and set <problems/> to that
+    list.
 
     You *MUST* *NOT* output anything at all in this step 1 beyond the
-    single `Agent` tool invocation.
+    `Glob` and `Agent` tool invocations.
     </step>
 
 2.  <step id="STEP 2: Summary">
@@ -192,7 +206,7 @@ Analyze documents for spelling, punctuation, or grammar errors
 
             <expand name="custom-dialog" arg1="--other">
                 CORRECTION: How would you like to proceed with this proposed correction?
-                ACCEPT: Apply the proposed correction.
+                ACCEPT: Apply this proposed correction.
                 REJECT: Skip this proposed correction.
             </expand>
 

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

@@ -33,10 +33,10 @@ Query foreign LLM for: <query><getopt-arguments/></query>
 
     ```text
         Agent(
-            name:          "ase-meta-chat",
-            description:   "Query Foreign LLM for Chat",
-            subagent_type: "ase:ase-meta-chat",
-            prompt:        <query/>
+            description:       "Query Foreign LLM for Chat",
+            subagent_type:     "ase:ase-meta-chat",
+            prompt:            <query/>,
+            run_in_background: false
         )
     ```
 

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

@@ -301,9 +301,9 @@ Procedure
             labels ultra short (basenames or module names only).
 
         2.  Dispatch the rendering to the `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/>")` and capture
+            calling the tool `Agent(description: "Diagram Rendering",
+            subagent_type: "ase:ase-meta-diagram", prompt:
+            "<mermaid-spec/>", run_in_background: false)` and capture
             its returned `text` field as <diagram/>.
 
     4.  Then emit the following <template/>, showing <diagram/> and

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

@@ -83,10 +83,10 @@ by querying *multiple* AIs for an *optimal consensus*.
 
     ```text
         Agent(
-            name:          "ase-meta-chat-<arg2/>",
-            description:   "Query Foreign LLM: <arg1/>",
-            subagent_type: "ase:ase-meta-chat",
-            prompt:        "<arg2/> <query/>"
+            description:       "Query Foreign LLM: <arg1/>",
+            subagent_type:     "ase:ase-meta-chat",
+            prompt:            "<arg2/> <query/>",
+            run_in_background: false
         )
     ```
 
@@ -94,7 +94,8 @@ by querying *multiple* AIs for an *optimal consensus*.
 
     Query only those foreign models whose token is contained in
     <getopt-option-models/> (where `all` selects every model); silently
-    skip all others:
+    skip all others. Emit *all* these `Agent` tool invocations *in one
+    single message* so they run in *parallel*:
 
     <if condition="<getopt-option-models/> contains `all` OR <getopt-option-models/> contains `chatgpt`">
     <expand name="agent" arg1="OpenAI ChatGPT" arg2="chatgpt"></expand>

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

@@ -83,11 +83,10 @@ Procedure
 
     ```text
         Agent(
-            name:          "ase-meta-review",
-            description:   "Review Investigation",
-            subagent_type: "ase:ase-meta-review",
-            mode:          "plan",
-            prompt:        "Review the staged changes."
+            description:       "Review Investigation",
+            subagent_type:     "ase:ase-meta-review",
+            prompt:            "Review the staged changes.",
+            run_in_background: false
         )
     ```
 
@@ -149,7 +148,7 @@ Procedure
         Then render a *three-column table* with one row per finding by
         using the following output <template/>. For each finding, repeat
         the third line, set <severity/> to its `severity` field, set
-        <dimension/> to its `dimension` field set <location/> to its
+        <dimension/> to its `dimension` field, set <location/> to its
         `location` field, and set <finding/> to its `finding` field.
 
         In the <location/> column, markup the `file:line` reference

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

@@ -41,10 +41,10 @@ Your objective is to *search* the *Internet*/*Web* for the following query:
     <define name="agent">
     ```text
         Agent(
-            name:          "ase-meta-search-<arg1/>",
-            description:   "Query Web Search Service: <arg1/>",
-            subagent_type: "ase:ase-meta-search",
-            prompt:        <content/>
+            description:       "Query Web Search Service: <arg1/>",
+            subagent_type:     "ase:ase-meta-search",
+            prompt:            <content/>,
+            run_in_background: false
         )
     ```
     </define>
@@ -64,6 +64,9 @@ Your objective is to *search* the *Internet*/*Web* for the following query:
     A backend is *selected* if `all` is in <getopt-option-services/> *OR*
     that backend's own name is in <getopt-option-services/>.
 
+    Then invoke the following tool once per *selected* backend, emitting
+    *all* invocations *in one single message* so they run in *parallel*:
+
     If the `perplexity` backend is *selected* and the MCP tool
     `perplexity_search` from the MCP server `search-perplexity` is available:
 

package/dst/ase-hello.js

@@ -1,23 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-import { Chalk } from "chalk";
-/*  auto-detecting chalk instance: colors on a TTY and degrades cleanly
-    on pipes/redirects (unlike ase-statusline.ts, which forces level 1
-    because Claude Code pipes its stdout)  */
-const c = new Chalk();
-/*  CLI command "ase hello"  */
-export default class HelloCommand {
-    register(program) {
-        program
-            .command("hello")
-            .description("Print a nice greeting to the terminal")
-            .option("-s, --subject <subject>", "subject to greet", "World")
-            .action((opts) => {
-            process.stdout.write(c.blue(`Hello ${opts.subject}!`) + "\n");
-            process.exit(0);
-        });
-    }
-}