@rse/ase 0.0.41 → 0.0.43

package/dst/ase-hello.js

@@ -3,11 +3,7 @@
 **  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";
-/*  forced-color chalk instance: stdout is a pipe under Claude Code,
-    so chalk auto-detection would yield level 0; force level 1 to keep
-    emitting ANSI sequences as the original implementation did  */
-const c = new Chalk({ level: 1 });
+import chalk from "chalk";
 /*  command-line handling  */
 export default class HelloCommand {
     log;
@@ -18,10 +14,10 @@ export default class HelloCommand {
     register(program) {
         program
             .command("hello")
-            .description("print a colored greeting message")
-            .option("-s, --subject <name>", "subject to greet", "Universe")
-            .action(async (opts) => {
-            process.stdout.write(`${c.red(`${opts.subject} World!`)}\n`);
+            .description("Print a nice greeting in red")
+            .option("-s, --subject <subject>", "subject to greet", "Hello")
+            .action((opts) => {
+            process.stdout.write(chalk.red(`${opts.subject} Universe!`) + "\n");
         });
     }
 }

package/dst/ase-kv.js

@@ -17,6 +17,11 @@ export class KV {
     static validateKey(key) {
         if (typeof key !== "string" || key.length === 0)
             throw new Error("kv: key must be a non-empty string");
+        if (key.trim().length === 0)
+            throw new Error("kv: key must not consist solely of whitespace");
+        /* eslint-disable-next-line no-control-regex */
+        if (/[\x00-\x1F\x7F]/.test(key))
+            throw new Error("kv: key must not contain control characters");
         if (key.length > KV.KEY_MAX_LEN)
             throw new Error(`kv: key must be no longer than ${KV.KEY_MAX_LEN} characters`);
     }
@@ -33,7 +38,7 @@ export class KV {
     /*  set a value under the given key; overwrites any existing value  */
     static set(key, val) {
         KV.validateKey(key);
-        KV.store.set(key, val);
+        KV.store.set(key, structuredClone(val));
     }
     /*  delete a value by key; returns true if a value existed  */
     static delete(key) {
@@ -46,6 +51,16 @@ export class KV {
         KV.store.clear();
         return n;
     }
+    /*  snapshot the entire store into a fresh map (for transactional batch)  */
+    static snapshot() {
+        return new Map(KV.store);
+    }
+    /*  restore the store from a previously taken snapshot  */
+    static restore(snap) {
+        KV.store.clear();
+        for (const [k, v] of snap)
+            KV.store.set(k, v);
+    }
 }
 /*  MCP registration entry point for in-memory key/value tools  */
 export class KVMCP {
@@ -57,14 +72,14 @@ export class KVMCP {
                 "Returns the value as JSON-encoded `text`; returns an empty string if no value is stored.",
             inputSchema: {
                 key: z.string()
-                    .describe("key identifier (non-empty string, up to 1024 characters)")
+                    .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)")
             }
         }, async (args) => {
             try {
                 if (!KV.has(args.key))
                     return { content: [{ type: "text", text: "" }] };
                 const val = KV.get(args.key);
-                const text = JSON.stringify(val);
+                const text = val === undefined ? "" : JSON.stringify(val);
                 return { content: [{ type: "text", text }] };
             }
             catch (err) {
@@ -80,8 +95,8 @@ export class KVMCP {
                 "The value can be any JSON-compatible type (string, number, boolean, null, array, object).",
             inputSchema: {
                 key: z.string()
-                    .describe("key identifier (non-empty string, up to 1024 characters)"),
-                val: z.any()
+                    .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)"),
+                val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.any()), z.record(z.string(), z.any())])
                     .describe("arbitrary JSON-compatible value to store under `key`")
             }
         }, async (args) => {
@@ -117,7 +132,7 @@ export class KVMCP {
                 "Returns a status `text` indicating whether a value existed and was removed.",
             inputSchema: {
                 key: z.string()
-                    .describe("key identifier (non-empty string, up to 1024 characters)")
+                    .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)")
             }
         }, async (args) => {
             try {
@@ -132,5 +147,89 @@ export class KVMCP {
                 return { isError: true, content: [{ type: "text", text: `kv_delete: ERROR: ${message}` }] };
             }
         });
+        /*  key/value batch  */
+        mcp.registerTool("kv_batch", {
+            title: "ASE key/value batch",
+            description: "Execute an array of in-memory key/value `commands` in a single MCP call. " +
+                "Each entry is an object `{ command: \"clear\"|\"set\"|\"get\"|\"delete\", key?, val? }` " +
+                "and is dispatched to the corresponding single-op tool. " +
+                "If `transactional` is true, the store is snapshotted up-front and rolled back on the " +
+                "first per-command error (remaining commands are skipped); otherwise per-command errors " +
+                "are recorded and execution continues. " +
+                "Returns a single `text` payload containing a JSON array of per-command result strings " +
+                "in the same format emitted by `kv_clear`/`kv_set`/`kv_get`/`kv_delete`. " +
+                "On transactional rollback, prior per-command result strings are rewritten to " +
+                "`kv_<cmd>: ROLLED-BACK` to truthfully reflect the post-rollback state, and the " +
+                "final entry remains `kv_batch: ERROR: <message>`.",
+            inputSchema: {
+                commands: z.array(z.object({
+                    command: z.enum(["clear", "set", "get", "delete"])
+                        .describe("the KV sub-command to execute"),
+                    key: z.string().optional()
+                        .describe("key identifier (required for `set`/`get`/`delete`)"),
+                    val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.any()), z.record(z.string(), z.any())]).optional()
+                        .describe("value to store (required for `set`)")
+                }))
+                    .describe("ordered list of KV commands to execute"),
+                transactional: z.boolean().optional()
+                    .describe("if true, snapshot the store and roll back on first error")
+            }
+        }, async (args) => {
+            const results = [];
+            const cmdNames = [];
+            const tx = args.transactional === true;
+            const snapshot = tx ? KV.snapshot() : null;
+            for (const c of args.commands) {
+                try {
+                    if (c.command === "clear") {
+                        const n = KV.clear();
+                        results.push(`kv_clear: OK: removed ${n} key(s)`);
+                        cmdNames.push("clear");
+                    }
+                    else if (c.command === "set") {
+                        if (c.key === undefined)
+                            throw new Error("kv_set: missing `key`");
+                        if (c.val === undefined)
+                            throw new Error("kv_set: missing `val`");
+                        KV.set(c.key, c.val);
+                        results.push(`kv_set: OK: stored key "${c.key}"`);
+                        cmdNames.push("set");
+                    }
+                    else if (c.command === "get") {
+                        if (c.key === undefined)
+                            throw new Error("kv_get: missing `key`");
+                        if (!KV.has(c.key))
+                            results.push("");
+                        else {
+                            const val = KV.get(c.key);
+                            results.push(val === undefined ? "" : JSON.stringify(val));
+                        }
+                        cmdNames.push("get");
+                    }
+                    else if (c.command === "delete") {
+                        if (c.key === undefined)
+                            throw new Error("kv_delete: missing `key`");
+                        const removed = KV.delete(c.key);
+                        results.push(removed ?
+                            `kv_delete: OK: removed key "${c.key}"` :
+                            `kv_delete: WARNING: no key "${c.key}" to remove`);
+                        cmdNames.push("delete");
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (tx) {
+                        if (snapshot !== null)
+                            KV.restore(snapshot);
+                        for (let i = 0; i < results.length; i++)
+                            results[i] = `kv_${cmdNames[i]}: ROLLED-BACK`;
+                        results.push(`kv_batch: ERROR: ${message}`);
+                        return { isError: true, content: [{ type: "text", text: JSON.stringify(results) }] };
+                    }
+                    results.push(`kv_${c.command}: ERROR: ${message}`);
+                }
+            }
+            return { content: [{ type: "text", text: JSON.stringify(results) }] };
+        });
     }
 }

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.0.41",
+    "version":                              "0.0.43",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -18,8 +18,8 @@
     "devDependencies": {
         "eslint":                           "9.39.4",
         "@eslint/js":                       "9.39.4",
-        "@typescript-eslint/parser":        "8.59.3",
-        "@typescript-eslint/eslint-plugin": "8.59.3",
+        "@typescript-eslint/parser":        "8.59.4",
+        "@typescript-eslint/eslint-plugin": "8.59.4",
         "eslint-plugin-promise":            "7.3.0",
         "eslint-plugin-import":             "2.32.0",
         "neostandard":                      "0.13.0",
@@ -30,7 +30,7 @@
         "nodemon":                          "3.1.14",
         "shx":                              "0.4.0",
 
-        "@types/node":                      "25.8.0",
+        "@types/node":                      "25.9.1",
         "@types/luxon":                     "3.7.1",
         "@types/which":                     "3.0.4",
         "@types/update-notifier":           "6.0.8",
@@ -55,11 +55,11 @@
         "zod":                              "4.4.3",
         "which":                            "7.0.0",
         "update-notifier":                  "7.3.1",
-        "shell-quote":                      "1.8.3",
+        "shell-quote":                      "1.8.4",
         "proper-lockfile":                  "4.1.2",
-        "write-file-atomic":                "4.0.0",
+        "write-file-atomic":                "8.0.0",
         "pacote":                           "21.5.0",
-        "ofetch":                           "1.4.1"
+        "ofetch":                           "1.5.1"
     },
     "engines": {
         "npm":                              ">=10.0.0",

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

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

package/plugin/meta/ase-dialog.md

@@ -134,3 +134,4 @@ Let the *user interactively choose* an answer.
             Do not output anything in this step!
         </if>
 </define>
+

package/plugin/meta/ase-persona.md

@@ -7,11 +7,12 @@ Ruleset Levels
 <define name="level1">
 -   You *MUST* *use* short synonyms
     ("big" not "extensive", "fix" not "implement a solution for").
--   You *MUST* *drop* articles ("a", "an", "the", etc).
--   You *MUST* *drop* filler ("just", "really", "basically", "actually", "simply", etc).
--   You *MUST* *drop* pleasantries ("sure", "certainly", "of course", "happy to", etc).
--   You *MUST* *drop* hedging ("I think", "maybe", "perhaps", "it seems",
-    "sort of", "probably", "I'm not sure but...", "it might be", etc).
+-   You *MUST* *drop* filler
+    ("just", "really", "basically", "actually", "simply", etc).
+-   You *MUST* *drop* pleasantries
+    ("sure", "certainly", "of course", "happy to", etc).
+-   You *MUST* *drop* hedging
+    ("I think", "maybe", "perhaps", "it seems", "sort of", "probably", "I'm not sure but...", "it might be", etc).
 -   You *MUST* *keep* technical terms exactly.
 -   You *MUST* *keep* code blocks unchanged.
 -   You *MUST* *keep* errors quoted exactly.
@@ -21,25 +22,37 @@ Ruleset Levels
 ### Level 2
 
 <define name="level2">
--   You *MUST* *use* abbreviations ("DB", "auth", "config", "req", "res", "fn", "impl", etc).
--   You *MUST* *use* arrows for causality ("X → Y").
--   You *MUST* *drop* conjunctions ("and", "but", "or", "so", "because", "however", "therefore", "although"), and instead *use* short sentences.
+-   You *MUST* *use* abbreviations
+    ("DB", "auth", "config", "req", "res", "fn", "impl", etc).
+-   You *MUST* *use* arrows for causality
+    ("X → Y").
+-   You *MUST* *drop* articles
+    ("a", "an", "the", etc).
+-   You *MUST* *drop* conjunctions
+    ("and", "but", "or", "so", "because", "however", "therefore", "although"),
+    and instead *use* short sentences.
 -   You *MUST* *drop* all fluff in wording.
 </define>
 
 ### Level 3
 
 <define name="level3">
--   You *MUST* *use* one word, when one word is enough.
--   You *MUST* *use* the sentence pattern: `<thing/> <action/> <reason/>.`
--   You *MUST* *keep* all technical substance.
+-   You *MUST* *use* only one word, when one word is clear enough.
+-   You *MUST* *use* only two words, when two words are clear enough.
+-   You *MUST* *use* the three sentence patterns
+    (dependending what information has to be expressed):
+    -   `<subject/> <action/> <object/>, <reason/>.` → e.g. "Cat eats fish, hungry."
+    -   `<subject/> <action/> <object/>.`            → e.g. "Dog chases ball."
+    -   `<subject/> <action/>.`                      → e.g. "Birds fly."
 -   You *MUST* *drop* all lists and just provide very short sentences.
+-   You *MUST* *keep* all technical substance.
 </define>
 
 Apply Persona
 -------------
 
--   *IMPORTANT*: Output *MUST* in all cases follow the following conditioned rules even if later skill rules say different:
+*IMPORTANT*: Output *MUST* in all cases follow the following conditioned
+rules even if later skill rules say different:
 
 -   <if condition="<ase-persona-style/> is 'writer'">
     -   You *MUST* use a decorative, eloquent, and explaining communication style of a writer.
@@ -50,11 +63,13 @@ Apply Persona
     -   You *MUST* use a brief, factual, and accurate communication style of an engineer.
     -   Apply ruleset "level1": <expand name="level1"/>
     </if>
+
 -   <if condition="<ase-persona-style/> is 'telegrapher'">
     -   You *MUST* use a very brief, factual, and abbreviating communication style of a telegrapher.
     -   Apply ruleset "level1": <expand name="level1"/>
     -   Apply ruleset "level2": <expand name="level2"/>
     </if>
+
 -   <if condition="<ase-persona-style/> is 'caveman'">
     -   You *MUST* use an ultra brief, rough and stuttering communication style of a caveman.
     -   Apply ruleset "level1": <expand name="level1"/>

package/plugin/meta/ase-plan.md

@@ -70,3 +70,4 @@ You *MUST* honor the following hints on this *task plan* format:
 -   In all sections, break all lines with a newline character
     after about 120 characters per line for better subsequent
     manual editing.
+

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.0.41",
+    "version":                              "0.0.43",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

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

@@ -33,78 +33,77 @@ code, for problems in its *logic* and *semantics* and its related
 
 <flow>
 
-1. <step id="STEP 1: Investigate Code Base">
-   In this STEP 1, 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.
-   Hints:
-
-   - During investigation in this STEP 1, do *not* output anything else,
-     especially do not give any further explanations or information.
-
-   - Focus on *practically relevant* cases and especially do *not*
-     investigate on theoretical or fictive cases.
-
-   - In case of problems related to *obvious or expected* errors,
-     they *should* be handled *near the origin*.
-
-   - In case of problems related to *theoretical or unexpected* errors,
-     they *should* be handled in parent scopes to avoid cluttering the
-     source code with too much error handling at all.
-
-   - In this STEP 1, still focus on the *problem only* and do *not*
-     investigate on any possible *solution*.
-   </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
-   points.
-
-   <template>
-   &#x1F7E0; PROBLEM (Severity: **<severity/>**): **P<n/>**: **<title/>**
-
-   <description/>
-   </template>
-
-   Hints:
-   - For the final results, do *not* output anything else, especially do
-     *not* give any further explanations or information.
-
-   - Uniquely identify the problems with `P<n/>` where <n/> is 1, 2, ...
-
-   - In <description/>, use *very brief* but 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> or
-     <template>HIGH</template>.
-
-   - *Additionally*, first call the `kv_clear()` tool of the `ase`
-     MCP service to clear the in-memory key/value store, and then, for
-     *every* reported problem, persist its problem analysis result
-     via the `kv_set` tool of the `ase` MCP service, using `key` set
-     to `ase-issue-P<n/>` and `val` set to `<title/>: <description/>`.
-   </step>
-
-3. <step id="STEP 3: Give Final Hint">
-   Finally, in this STEP 3, 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>
-   </step>
+1.  <step id="STEP 1: Investigate Code Base">
+    In this STEP 1, 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,
+        especially do not give any further explanations or information.
+
+    -   **Practical Relevance Only**:
+        Focus on *practically relevant* cases and especially do *not*
+        investigate on theoretical or fictive cases.
+
+    -   **Problem Focus Only**:
+        Still focus on the *problem only* and do *not* already
+        investigate on any possible *solution*.
+    </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
+    points.
+
+    <template>
+    &#x1F7E0; PROBLEM (Severity: **<severity/>**): **P<n/>**: **<title/>**
+
+    <description/>
+    </template>
+
+    Hints:
+
+    -   For the final results, do *not* output anything else, especially do
+        *not* give any further explanations or information.
+
+    -   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> or
+        <template>HIGH</template>.
+
+    -   *Additionally*, persist all reported problems in a *single*
+        `kv_batch` call to the `ase` MCP service with `transactional`
+        set to `true`. The `commands` parameter array of this call
+        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:
+
+    <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>
+    </step>
 
 </flow>
 

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

@@ -121,32 +121,58 @@ permitted way to persist artifacts is via `task_save(...)`.
 
 3.  **Internalize Crafting Tenets**:
 
-    Internalize and honor the following tenets.
+    You *MUST* internalize and honor the following tenets when crafting the new feature.
     Do not output anything.
 
-    1.  *Recommended* Tenets (generic):
+    1.  Generic Tenets:
+
+        -   **Separation of Concerns**:
+            Clearly separate all individual concerns as good as possible.
+
+        -   **Code Base Alignment**:
+            Strictly align with the existing source code base by exactly
+            following its coding style, its structure, its naming
+            conventions, etc.
+
+    2.  Specific Tenets:
 
         -   **Surgical Changes**:
             Keep source code changes always as small as possible.
 
-        -   **Separation of Concerns**:
-            Clearly separate all individual concerns as good as possible.
+        -   **Clear Minimal Scope**:
+            Establish explicit boundaries for the new feature.
+            Avoid feature scope creep and over-engineering.
+
+        -   **Keep it Simple, Stupid (KISS)**:
+            Build with the simplest design that solves the real problem.
+            Avoid over-engineering.
+
+        -   **You Aren't Gonna Need It (YAGNI)**:
+            Build for today's actual needs, not speculative futures.
+            Avoid premature optimizations, premature abstractions,
+            over-configurability, etc.
 
-        -   **Single Responsibility Principle**:
-            Every module, class, or function should have only one reason to change.
+        -   **Don't Repeat Yourself (DRY)**:
+            Avoid redundancies, but honor the *Rule of Three*: Don't
+            abstract on the first occurrence -- tolerate (small)
+            duplication on the second -- factor out on the third only.
 
-        -   **Behavior Preservation**:
-            Refactoring changes only re-structure, never change any observable behavior.
+        -   **Single Responsibility Principle (SRP)**:
+            Every module, class, or function should have only one reason
+            to change.
 
-        -   **Align with Code Base**:
-            Strictly align with the existing code base by exactly following its
-            coding style, its structure, its naming conventions, etc.
+        -   **Loose Coupling, High Cohesion**:
+            Strike for good modularity by a set of small, focused parts
+            (high cohesion), connected by thin, explicit wires and
+            interfaces (loose coupling).
 
-    2.  *Essential* Tenets (feature crafting specific):
+        -   **Clear Interfaces**:
+            Design clear interfaces, contracts, and data models --
+            with high attention to boundaries and modularity.
 
-        -   **High Cohesion, Low Coupling**:
-            Strike for a set of small, focused parts (high cohesion) connected by
-            thin, explicit wires (low coupling).
+        -   **Non-Functional Requirements**:
+            Honor the non-functional requirements Performance, Security,
+            Scalability, Comprehensibility.
 
 4.  **Find Feature Crafting Approaches**:
 
@@ -167,14 +193,20 @@ permitted way to persist artifacts is via `task_save(...)`.
         ` ⚝ **RECOMMENDATION** ⚝`. All other approaches receive an
         empty <annotation/>. Do *not* output anything in this sub-step.
 
-    4.  *Now* report each approach with the following <template/>,
+    4.  Indicate start of reporting by showing the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ┈┈┈┈┈┈┈┈────────━━━━━━━━**(** `APPROACHES-BEGIN` **)**━━━━━━━━────────┈┈┈┈┈┈┈┈
+        </template>
+
+    5.  Now report each approach with the following <template/>,
         inlining its pros/cons derived in sub-step 2:
 
         <template>
-        &#x1F535; **APPROACH A<n/>**<annotation/>: *<summary/>*
-        ● [...]
-        ● [...]
-        ● [...]
+        ● **APPROACH A<n/>**<annotation/>: *<summary/>*
+        ○ [...]
+        ○ [...]
+        ○ [...]
         ⊕ *pro*: [...]
         ⊖ *con*: [...]
         <optional-diagram/>
@@ -199,6 +231,12 @@ permitted way to persist artifacts is via `task_save(...)`.
             `**After:**`); never side-by-side. Omit <optional-diagram/>
             entirely for simple or purely local situation.
 
+    6.  Indicate end of reporting by showing the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ┈┈┈┈┈┈┈┈────────━━━━━━━━**(**  `APPROACHES-END`  **)**━━━━━━━━────────┈┈┈┈┈┈┈┈
+        </template>
+
 5.  **Choose Feature Crafting Approach**:
 
     1.  If <getopt-option-auto/> is equal `false`: