@rse/ase 0.9.50 → 0.9.52

package/dst/ase-hook.js

@@ -145,12 +145,9 @@ export default class HookCommand {
             pluginRootVars = ["PLUGIN_ROOT", "CLAUDE_PLUGIN_ROOT"];
         else
             pluginRootVars = ["CLAUDE_PLUGIN_ROOT"];
-        let pluginRoot = "";
-        for (const pluginRootVar of pluginRootVars)
-            if ((process.env[pluginRootVar] ?? "") !== "") {
-                pluginRoot = process.env[pluginRootVar];
-                break;
-            }
+        const pluginRoot = pluginRootVars
+            .map((varName) => process.env[varName] ?? "")
+            .find((value) => value !== "") ?? "";
         if (pluginRoot === "")
             throw new Error(`${pluginRootVars.join("/")} environment variable is not set`);
         return pluginRoot;
@@ -254,7 +251,7 @@ export default class HookCommand {
         const guidance = setting("agent.guidance", "ASE_GUIDANCE_LEVEL", "normal");
         const boxing = setting("project.boxing", "ASE_PROJECT_BOXING", "white");
         /*  determine headless mode  */
-        const headless = (process.env.ASE_HEADLESS ?? "false") === "true" ? "true" : "false";
+        const headless = process.env.ASE_HEADLESS === "true" ? "true" : "false";
         /*  provide ASE information to Anthropic Claude Code CLI shell commands
             (Anthropic Claude Code CLI only -- GitHub Copilot CLI has no equivalent mechanism)  */
         const envFile = tool === "claude" ? (process.env.CLAUDE_ENV_FILE ?? "") : "";
@@ -300,15 +297,14 @@ export default class HookCommand {
             "systemMessage" field for this -- GitHub Copilot CLI has no equivalent);
             the trailing help hint is emitted only if the guidance level asks for it  */
         const banner = "\n" +
-            `\n⧉ ASE: ⎈ version: ${versionCurrentPlugin}${versionHint !== "" ? " " + versionHint.replaceAll(/\*/g, "") : ""}` +
+            `\n⧉ ASE: ⎈ version: ${versionCurrentPlugin}${versionHint !== "" ? " " + versionHint.replace(/\*/g, "") : ""}` +
             `\n⧉ ASE: ※ user: ${userId}, ⚑ project: ${projectId}` +
             `\n⧉ ASE: ◉ task: ${taskId}, ⏻ session: ${sessionId}` +
             `\n⧉ ASE: ☯ persona: ${persona}, ▶ guidance: ${guidance}, ▢ boxing: ${boxing}` +
             (guidance === "normal" || guidance === "verbose" ?
                 "\n" +
                     "\n⧉ ASE: ▷ hint: use \"/ase-help-intent <intent-description>\" for skill command proposal" +
-                    "\n⧉ ASE: ▷ hint: use \"/ase-help-skill [<skill-name>]\" for skill catalog or skill manpage" : "") +
-            "\n";
+                    "\n⧉ ASE: ▷ hint: use \"/ase-help-skill [<skill-name>]\" for skill catalog or skill manpage" : "");
         /*  inject markdown into session context.
             Anthropic Claude Code CLI and OpenAI Codex CLI expect the context nested in
             "hookSpecificOutput"; GitHub Copilot CLI expects a flat top-level
@@ -434,10 +430,10 @@ export default class HookCommand {
         tools, but the decision logic is shared by the "pre-tool-use" and
         "permission-request" handlers.  */
     decideApproval(tool, spec, input) {
-        const toolName = typeof input[spec.toolNameField] === "string" ?
-            input[spec.toolNameField] : "";
-        let toolInput = {};
+        const rawName = input[spec.toolNameField];
         const rawInput = input[spec.toolInputField];
+        const toolName = typeof rawName === "string" ? rawName : "";
+        let toolInput = {};
         if (spec.toolInputIsString && typeof rawInput === "string")
             toolInput = this.parseJSON(rawInput, toolInputSchema);
         else if (!spec.toolInputIsString && typeof rawInput === "object" && rawInput !== null) {

package/dst/ase-statusline.js

@@ -159,6 +159,23 @@ const probeMemory = () => {
         return { used: 0, total: 0 };
     }
 };
+/*  set of reasoning effort levels GitHub Copilot CLI offers in its effort picker  */
+const EFFORTS = new Set([
+    "low", "medium", "high", "xhigh", "max"
+]);
+/*  split a GitHub Copilot CLI "model.display_name" into its plain model name and its
+    reasoning effort: Copilot CLI renders the display name as the model label, followed
+    by the optional request multiplier, the optional reasoning effort and the optional
+    context tier, all separated by " · " (e.g. "gpt-5.4 (2x) · high · 1M context"), so
+    only a segment matching a known effort level is taken as the effort  */
+const splitCopilotModel = (display) => {
+    const parts = display.split(" · ");
+    const effort = parts.filter((part) => EFFORTS.has(part.toLowerCase()));
+    const name = parts.filter((part) => !EFFORTS.has(part.toLowerCase()));
+    if (effort.length === 0)
+        return { name: display, effort: "" };
+    return { name: name.join(" · "), effort: effort[0].toLowerCase() };
+};
 /*  memoize a zero-argument function, computing its value at most once on first use  */
 const memoize = (fn) => {
     let cache = null;
@@ -286,6 +303,15 @@ export default class StatuslineCommand {
                 }
                 return { taskId, persona, guidance };
             });
+            const getModel = memoize(() => {
+                const display = data.model?.display_name ?? "";
+                /*  under GitHub Copilot CLI the reasoning effort is only available as
+                    a segment of the display name, so split it off again and let the
+                    regular "effort" field of Anthropic Claude Code CLI still win  */
+                const split = tool === "copilot" && display !== "" ?
+                    splitCopilotModel(display) : { name: display, effort: "" };
+                return { name: split.name, effort: data.effort?.level ?? split.effort };
+            });
             const getGit = memoize(() => probeGit(data.workspace?.current_dir ?? ""));
             const getMem = memoize(() => probeMemory());
             /*  identifier to renderer map: each callback fetches its own information
@@ -308,12 +334,12 @@ export default class StatuslineCommand {
                 s: () => emit(`${prefix("⏻", "session")}${c.bold(getSession())}`),
                 /*  ==== MODEL ====  */
                 m: () => {
-                    const model = data.model?.display_name ?? "";
-                    emit(`${prefix("⚙", "model")}${c.bold(model)}`);
+                    const { name } = getModel();
+                    emit(`${prefix("⚙", "model")}${c.bold(name)}`);
                 },
                 e: () => {
-                    const effort = data.effort?.level ?? "unknown";
-                    emit(`${prefix("⚒", "effort")}${c.bold(effort)}`);
+                    const { effort } = getModel();
+                    emit(`${prefix("⚒", "effort")}${c.bold(effort !== "" ? effort : "unknown")}`);
                 },
                 t: () => {
                     const thinking = data.thinking?.enabled === true ? "yes" : "no";

package/dst/ase-task.js

@@ -451,7 +451,8 @@ export class TaskMCP {
         mcp.registerTool("ase_task_save", {
             title: "ASE task save",
             description: "Persist a task as `text` under `id`. " +
-                "Overwrites any existing task for the same `id`.",
+                "Overwrites any existing task for the same `id`. " +
+                "Returns the persisted task as `text`, prepared for improved rendering.",
             inputSchema: {
                 id: z.string()
                     .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')"),
@@ -461,8 +462,12 @@ export class TaskMCP {
         }, async (args) => {
             try {
                 Task.save(this.log, args.id, args.text);
+                /*  return the prepared content, so a caller reusing the
+                    just-saved plan instead of re-loading it still receives
+                    the rendering-prepared variant  */
+                const text = Markdown.prepare(args.text);
                 return {
-                    content: [{ type: "text", text: `OK: saved task "${args.id}"` }]
+                    content: [{ type: "text", text }]
                 };
             }
             catch (err) {

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.50",
+    "version":                              "0.9.52",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -23,14 +23,14 @@
         "eslint-plugin-promise":            "7.3.0",
         "eslint-plugin-import":             "2.32.0",
         "neostandard":                      "0.13.0",
-        "globals":                          "17.7.0",
+        "globals":                          "17.8.0",
         "typescript":                       "6.0.3",
 
         "@rse/stx":                         "1.1.6",
         "nodemon":                          "3.1.14",
         "shx":                              "0.4.0",
 
-        "@types/node":                      "26.1.1",
+        "@types/node":                      "26.1.2",
         "@types/luxon":                     "3.7.2",
         "@types/which":                     "3.0.4",
         "@types/update-notifier":           "6.0.8",
@@ -42,18 +42,18 @@
     },
     "dependencies": {
         "commander":                        "15.0.0",
-        "@dotenvx/dotenvx":                 "2.18.0",
+        "@dotenvx/dotenvx":                 "2.19.1",
         "yaml":                             "2.9.0",
         "valibot":                          "1.4.2",
-        "execa":                            "10.0.0",
+        "execa":                            "10.0.1",
         "mkdirp":                           "3.0.1",
         "@hapi/hapi":                       "21.4.10",
         "beautiful-mermaid":                "1.1.3",
         "cli-table3":                       "0.6.5",
-        "chalk":                            "5.6.2",
+        "chalk":                            "6.0.0",
         "pretty-ms":                        "9.3.0",
         "luxon":                            "3.7.2",
-        "@modelcontextprotocol/sdk":        "1.29.0",
+        "@modelcontextprotocol/sdk":        "1.30.0",
         "json-asty":                        "1.3.4",
         "zod":                              "4.4.3",
         "which":                            "7.0.0",

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

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

package/plugin/agents/ase-code-lint.md

@@ -13,6 +13,10 @@ Workflow
 --------
 
 1.  Set the requested context: <context>$ARGUMENTS</context>.
+    The *first* whitespace-separated token of <context/> is the
+    comma-separated *aspect set* <aspects/> (a non-empty subset of the
+    aspect ids `A01`...`A20`). The *remaining* tokens are the source
+    code files to check.
 
 2.  Use the `Read` tool to read all source code files referenced by
     <context/>, plus all *related* source code files needed to really
@@ -25,7 +29,9 @@ Workflow
 4.  Set <problems/> to empty.
     Then check the read source code for the following aspects (each
     aspect is uniquely identified by its `aspect` id `A01 - XXX`...`A20
-    - XXX`):
+    - XXX`), but *strictly limited* to those aspects whose id is
+    contained in the aspect set <aspects/> -- all other aspects are
+    *not* checked and their problems are *never* reported:
 
     -   **A01 - FORMATTING**:
         Check for inconsistently formatted code and badly vertically
@@ -95,6 +101,20 @@ Workflow
         site as close as possible. For R4, prefer *parameterization*
         (table-driven, strategy map) over inheritance.
 
+        **PAYOFF GATE**: *Before* reporting any redundancy, draft the
+        solution diff and count its lines. The removed lines *MUST* be at
+        least *twice* the added lines (ratio >= 2:1, i.e. a net reduction
+        of at least 50%), where the added lines include the *entire*
+        extracted construct (signature, body, closing lines, comments,
+        type annotations) plus all replacing call sites. A break-even
+        proposal (e.g. 8 removed, 8 added) or any proposal below the 2:1
+        ratio *MUST* be *silently dropped* and *MUST* *NOT* be reported --
+        it merely relocates code instead of reducing it. Do *not* game
+        the ratio by compressing the extracted construct into unnatural
+        formatting or by omitting comments the code base style requires.
+        Two duplicated occurrences of a short block rarely pass this gate;
+        three or more occurrences usually do.
+
     -   **A07 - PATTERNS**:
         Check for broken design patterns, broken conventions, or broken
         best practices.

package/plugin/agents/ase-meta-proximity.md

@@ -0,0 +1,133 @@
+---
+name: ase-meta-proximity
+description: "Determine the Conceptual Proximity of a Topic"
+effort: high
+tools:
+    - "Agent"
+---
+
+@../meta/ase-control.md
+
+<define name="gather-facts">
+<if condition="<ground/> is equal `true`">
+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: "Search the Internet/Web and gather facts about <arg1/>",
+    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
+silently falls back to model knowledge. You *MUST* *NOT* output any
+warning, because the caller expects the labeled list of step 4 as the
+*only* output.
+</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>
+
+1.  Set <args>$ARGUMENTS</args>, the single whitespace-separated string.
+
+    <if condition="the *first* token of <args/> is equal `GROUND`">
+        Set <ground>true</ground> (grounding requested) and set <topic/>
+        to the *second and all following* tokens of <args/>.
+    </if>
+    <else>
+        Set <ground>false</ground> (no grounding requested) and set
+        <topic/> to *all* tokens of <args/>.
+    </else>
+
+    You *MUST* *NOT* output anything related to this step.
+
+2.  *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.
+
+    You *MUST* *NOT* output anything related to this step.
+
+3.  *Determine Proximity*:
+
+    Determine the *conceptual proximity* of the current <topic/> along
+    three *dimensions* in parallel:
+
+    -   **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 *child* 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 child topics <child-1/> to <child-4/> in the facts of
+        <facts-children/> and do not contradict them.
+
+    You *MUST* determine *exactly* one parent, *exactly* four siblings,
+    and *exactly* four children. All nine proximity topics *MUST* be
+    *distinct* from each other and *MUST* *NOT* be <topic/> itself or a
+    mere synonym or spelling variant of it. You *MUST* *NOT* output
+    anything related to this step.
+
+4.  Return *exclusively* the following <template/> (no prose, no
+    preamble, no summary, and no Markdown formatting):
+
+    <template>
+    TOPIC:   <topic/>
+    PARENT:  <parent/>
+    SIBLING: <sibling-1/>
+    SIBLING: <sibling-2/>
+    SIBLING: <sibling-3/>
+    SIBLING: <sibling-4/>
+    CHILD:   <child-1/>
+    CHILD:   <child-2/>
+    CHILD:   <child-3/>
+    CHILD:   <child-4/>
+    </template>
+

package/plugin/etc/stx.conf

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

package/plugin/meta/ase-common-dissect.md

@@ -0,0 +1,110 @@
+
+Dissect Skill Common Steps
+==========================
+
+<define name="dissect-derive">
+
+*Dissect* <content/> into *cohesive parts* by strictly honoring the
+following ruleset:
+
+1.  *Separate domain-wise and logically*: every part *MUST* be a
+    *self-contained* unit of work with a *single*, coherent purpose (one
+    domain, one concern, one logical change), so it can be implemented,
+    reviewed, and committed entirely *on its own*. A *technical* split
+    -- one part per file, per directory, per file type, or per technical
+    layer -- is usually *not* the obvious and intended one: files are
+    merely *where* the change lands, while a part is defined by *what*
+    it achieves. Cut along the *semantics* first, and let a file-wise
+    boundary result only when it *coincides* with a domain boundary.
+
+2.  *Bound the part count*: derive at least *2* and at most
+    *<getopt-option-max-parts/>* parts. Prefer *fewer* and *larger*
+    cohesive parts over *many* and *tiny* ones.
+
+3.  *Assign totally and disjointly*: *every* input element of the epic
+    *MUST* be assigned to *exactly one* part -- no input element is
+    dropped, and no input element occurs in two parts. An input element
+    which itself spans *multiple* domains or concerns *MAY* be *split*
+    into two or more *sub-elements*, which are then assigned like
+    ordinary input elements, provided the sub-elements *together* cover
+    the original element *completely*, *never* overlap, and each one
+    stays *self-contained* in the input form the calling skill defines.
+    Split *only* when rule 1 forces it: an input element whose content
+    fits a *single* part stays *unsplit*.
+
+4.  *Keep mutually dependent elements together*: input elements which
+    only make sense *together* -- they reference each other, one is the
+    precondition of the other, or splitting them would leave a part
+    broken -- *MUST* land in the *same* part.
+
+5.  *Never invent*: parts are formed *exclusively* from the input
+    elements of the epic. Do *not* add scope, do *not* re-interpret the
+    input elements, and do *not* re-word them beyond what a part-local
+    summary requires.
+
+6.  *Slug and identify every part*: per part derive a <feature-slug/>
+    from its scope, matching the regexp `^[a-z][a-z0-9-]{0,23}$` and
+    *unique* across all parts, and then set
+    <part-id><arg3/>-<feature-slug/></part-id>, where <arg3/> is the
+    *id prefix* the calling skill passed in.
+
+7.  *Order for implementation*: order the parts so that a part *never*
+    depends on a later one, and number them consecutively as <part-no/>,
+    starting at `1`.
+
+8.  *Honor the dissection hint*:
+    <if condition="<arg2/> is not empty">
+    Set <hint><arg2/></hint>. The user explicitly told *how* the epic
+    should be split -- e.g. which input elements belong together, along
+    which axis to cut, or how many parts to aim at -- so you *MUST*
+    follow this <hint/> as closely as possible and let it *override* the
+    default grouping of rule 1. It *MUST NOT* override the rules 2-7,
+    though: the part count stays bounded, the assignment stays total and
+    disjoint, mutually dependent elements stay together, nothing is
+    invented, every part stays uniquely slugged, and the order stays
+    dependency-free. If the <hint/> conflicts with one of these rules,
+    honor the rule and follow the <hint/> only as far as the rule
+    permits.
+    </if>
+    <else>
+    No dissection hint was given, so the grouping follows the rules 1-7
+    alone. Do not output anything.
+    </else>
+
+Per part, additionally derive an *ultra brief* <scope/> (*what* the part
+covers) and an *ultra brief* <rationale/> (*why* exactly these input
+elements form *one* cohesive part). Store the resulting parts in
+<parts/> and their number in <n/>.
+
+<if condition="fewer than 2 cohesive parts exist">
+The epic is *not* dissectable, because it carries a *single* cohesive
+purpose (or too few input elements) and splitting it would only produce
+artificial fragments. Only output the following <template/> and then
+immediately *STOP* processing the entire current skill:
+
+<template>
+⧉ **ASE**: ✪ skill: **<arg1/>**, ▶ status: **epic not dissectable**
+</template>
+</if>
+
+</define>
+
+<define name="dissect-report">
+
+Report the derived <parts/> with the following <template/>, emitting
+*one* table row per part in <parts/>, in their derived order. Keep
+<scope/> and <rationale/> each to *one* ultra brief sentence, align all
+column edges of the table, and do *not* output any further explanation:
+
+<template>
+<ase-tpl-head title="DISSECTION" subtitle="<arg1/>">
+
+| Part            | Id           | Scope    | Rationale    |
+| --------------- | ------------ | -------- | ------------ |
+| **P<part-no/>** | `<part-id/>` | <scope/> | <rationale/> |
+| [...]           | [...]        | [...]    | [...]        |
+
+<ase-tpl-foot title="DISSECTION" subtitle="<arg1/>">
+</template>
+
+</define>

package/plugin/meta/ase-common-task.md

@@ -65,9 +65,11 @@ Task Skill Common Steps
     *and* a `ase_task_save(id: '<ase-task-id/>', ...)` tool call
     exists earlier in the current session
 ">
-    Set <text/> to the `text` argument of the most recent
-    `ase_task_save(id: '<ase-task-id/>', ...)` tool call,
-    *without* calling `ase_task_load` again. Set <status>plan
+    Set <text/> to the `text` *output* field of the most recent
+    `ase_task_save(id: '<ase-task-id/>', ...)` tool call -- this is
+    the rendering-prepared plan content and *MUST NOT* be confused
+    with the `text` *argument* passed into that call -- *without*
+    calling `ase_task_load` again. Set <status>plan
     reused</status>. Do not output anything.
 </if>
 <else>

package/plugin/meta/ase-control.md

@@ -95,3 +95,56 @@ Control Flow Constructs
     is finished and no further repetitions are performed. This construct
     is expanded into nothing. Do not output anything.
 
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <agent <attr/>="<value/>" [...]><agent-body/></agent>:
+
+    This specifies the *invocation* of a *sub-agent* through the
+    `Agent` tool. Every XML attribute is passed *verbatim* as the
+    identically named parameter of the `Agent` tool (e.g. `description`,
+    `subagent_type`, `run_in_background`, `isolation`, `model`), and
+    <agent-body/> is passed as its `prompt` parameter.
+
+    The *sole exception* is the *reserved* attribute `result="<var/>"`,
+    which is *not* passed on but instead *binds* the result returned
+    by the sub-agent to the placeholder `<<var/>/>`. This construct is
+    expanded to the result returned by the sub-agent if `result` is
+    *absent*, or into nothing if `result` is *present*. Do not output
+    anything else.
+
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <agent-consolidation [group=<agent-group/>]/>
+
+    This specifies the merging of all the Git WorkTrees created by the
+    <agent/> calls with either are identified with the unique group
+    <agent-group/> or all <agent/> calls in the last <parallel/> section
+    of the context. After merging a single Git WorkTree, remove the Git
+    WorkTree.
+
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <skill name="<id/>" [args="<args/>"] [result="<var/>"]/>:
+
+    This specifies the *invocation* of another *skill* through the
+    `Skill` tool, with its `skill` parameter set to <id/> and its `args`
+    parameter set to <args/> (or to the empty string if the `args`
+    attribute is absent).
+
+    The *reserved* attribute `result="<var/>"` *binds* the result
+    returned by the skill to the placeholder `<<var/>/>`, exactly
+    as for <agent/>. This construct is *always* *self-closing*: a
+    *body-bearing* `<skill>` element is *never* an invocation. This
+    construct is expanded to the result returned by the skill if
+    `result` is *absent*, or into nothing if `result` is *present*. Do
+    not output anything else.
+
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <parallel><parallel-body/></parallel>:
+
+    This specifies a <parallel-body/> whose <agent/> and <skill/>
+    invocations are *all* dispatched *concurrently*: you *MUST* emit
+    them *in one single message* instead of one per turn, and this
+    construct is finished only once *all* of them have returned. If two
+    or more of these invocations bind the *same* `result` name, the
+    corresponding placeholder carries an *array* of their results, in
+    the order of their occurrence in <parallel-body/>. This construct is
+    expanded to its <parallel-body/>. Do not output anything else.
+

package/plugin/meta/ase-format-task.md

@@ -70,3 +70,9 @@ You *MUST* honor the following hints on this *task* format:
     after about 100 characters per line for better subsequent
     manual editing.
 
+-   You *MUST* *NEVER* break a line *inside* an inline code span
+    <template>`<code/>`</template>, as a code span split across two
+    lines renders badly. Instead, break the line *before* its opening
+    backtick or *after* its closing backtick, even if this means
+    breaking the line noticeably earlier than after 100 characters.
+

package/plugin/meta/ase-skill.md

@@ -209,18 +209,18 @@ MCP Tool Calls
 Skill Identification
 --------------------
 
--   *IMPORTANT*: Set <skill></skill> (set to empty)
+-   *IMPORTANT*: Set <purpose></purpose> (set to empty)
     and <skill-name></skill-name> (set name to empty).
 
-    In case <skill/> later becomes *not* empty by defining it as <skill
-    name="<name/>"><body/></skill>, set <skill-name><name/></skill-name>
-    (set skill name to name), and then (but only if ((`$1` is *NOT* equal
-    to `-h` or `--help`) *AND* (<ase-guidance-level/> is equal to `normal`
-    or `verbose`))) you *MUST* once output the following output
-    <template/>:
+    In case <purpose/> later becomes *not* empty by defining it as
+    <purpose name="<name/>"><body/></purpose>, set
+    <skill-name><name/></skill-name> (set skill name to name), and then
+    (but only if ((`$1` is *NOT* equal to `-h` or `--help`) *AND*
+    (<ase-guidance-level/> is equal to `normal` or `verbose`))) you *MUST*
+    once output the following output <template/>:
 
     <template>
-    ⧉ **ASE**: ✪ skill: **<skill-name/>**, ✦ purpose: **<skill/>**, ▶ status: **skill started**
+    ⧉ **ASE**: ✪ skill: **<skill-name/>**, ✦ purpose: **<purpose/>**, ▶ status: **skill started**
     </template>
 
     Later (but only if ((`$1` is *NOT* equal to `-h` or `--help`) *AND*

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.50",
+    "version":                              "0.9.52",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -16,7 +16,7 @@
     "devDependencies": {
         "@rse/stx":                         "1.1.6",
         "markdownlint":                     "0.41.1",
-        "markdownlint-cli2":                "0.23.1",
+        "markdownlint-cli2":                "0.23.2",
         "eslint":                           "10.8.0",
         "@eslint/markdown":                 "8.0.3",
         "eslint-markdown":                  "0.12.1"