@rse/ase 0.9.6 → 0.9.7

package/dst/ase-markdown.js

@@ -0,0 +1,235 @@
+/*
+**  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 { z } from "zod";
+/*  the reusable functionality  */
+export class Markdown {
+    /*  prepare Markdown for improved rendering by rewriting
+        unordered bullet paragraphs -- replacing the "-"/"*" bullet marker with
+        "◯" and splitting multi-line inline code spans into per-line single-line
+        spans (so each physical line carries its own closed backtick span).
+        Fenced code blocks (``` / ~~~) are detected line-wise and passed
+        through entirely verbatim, so neither the inline-span splitting nor the
+        bullet-marker rewriting ever touches their contents.  */
+    static prepare(text) {
+        if (typeof text !== "string")
+            throw new Error("markdown: text must be a string");
+        /*  segment the input line-wise into alternating non-fenced and
+            fenced regions: a fenced code block opens with a line whose first
+            non-whitespace content is a run of 3+ backticks or tildes and
+            closes with a matching-or-longer run of the same marker; fenced
+            regions are emitted verbatim while only non-fenced regions are
+            handed to the rewriting passes below  */
+        const lines = text.split("\n");
+        let result = "";
+        let buf = "";
+        let inFence = false;
+        let fenceCh = "";
+        let fenceLen = 0;
+        const flush = () => {
+            if (buf !== "") {
+                result += Markdown.rewrite(buf);
+                buf = "";
+            }
+        };
+        for (let li = 0; li < lines.length; li++) {
+            const line = lines[li];
+            const nl = li < lines.length - 1 ? "\n" : "";
+            const m = line.match(/^(\s*)(`{3,}|~{3,})/);
+            if (!inFence && m) {
+                /*  a fence-opening line: flush the pending non-fenced buffer,
+                    enter fenced mode, and emit the opener verbatim  */
+                flush();
+                inFence = true;
+                fenceCh = m[2][0];
+                fenceLen = m[2].length;
+                result += line + nl;
+            }
+            else if (inFence) {
+                /*  inside a fenced block: emit verbatim and, on a matching
+                    closing fence line, leave fenced mode  */
+                result += line + nl;
+                const c = line.match(/^(\s*)(`{3,}|~{3,})\s*$/);
+                if (c && c[2][0] === fenceCh && c[2].length >= fenceLen)
+                    inFence = false;
+            }
+            else
+                /*  a regular non-fenced line: accumulate for the passes  */
+                buf += line + nl;
+        }
+        flush();
+        return result;
+    }
+    /*  apply the inline-span and bullet-marker rewriting passes to a chunk of
+        non-fenced Markdown text (see prepare() for fenced-block handling)  */
+    static rewrite(text) {
+        /*  PASS 1: rewrite single-backtick inline code spans that carry
+            backslash-escaped backticks (`\``) into CommonMark-correct spans.  */
+        {
+            let pre = "";
+            let j = 0;
+            while (j < text.length) {
+                const ch = text[j];
+                if (ch !== "`") {
+                    /*  literal backslash-escaped backtick *outside* any span
+                        is left verbatim for later scanning  */
+                    pre += ch;
+                    j++;
+                    continue;
+                }
+                /*  scan an opening single-backtick span, capturing its raw
+                    inner content up to the matching unescaped close backtick  */
+                let inner = "";
+                let k = j + 1;
+                let closed = false;
+                let escaped = false;
+                while (k < text.length) {
+                    const c = text[k];
+                    if (c === "\\" && k + 1 < text.length && text[k + 1] === "`") {
+                        inner += "\\`";
+                        escaped = true;
+                        k += 2;
+                        continue;
+                    }
+                    if (c === "`") {
+                        closed = true;
+                        break;
+                    }
+                    inner += c;
+                    k++;
+                }
+                if (!closed || !escaped) {
+                    /*  not an escaped-backtick span: emit the opening backtick
+                        verbatim and continue scanning from just after it  */
+                    pre += "`";
+                    j++;
+                    continue;
+                }
+                /*  un-escape inner `\`` into literal backticks, then choose a
+                    fence longer than the longest internal backtick run  */
+                const content = inner.replace(/\\`/g, "`");
+                let maxRun = 0;
+                let run = 0;
+                for (const c of content) {
+                    if (c === "`") {
+                        run++;
+                        if (run > maxRun)
+                            maxRun = run;
+                    }
+                    else
+                        run = 0;
+                }
+                const fence = "`".repeat(maxRun + 1);
+                const pad = (content.startsWith("`") || content.endsWith("`")) ? " " : "";
+                pre += `${fence}${pad}${content}${pad}${fence}`;
+                j = k + 1;
+            }
+            text = pre;
+        }
+        /*  PASS 2: split multi-line inline code spans by scanning the
+            entire text character-by-character while tracking whether we
+            are currently inside an active backtick (U+0060) span; on
+            every "<newline><whitespaces>" sequence encountered while
+            inside a span, close the span before the break and re-open
+            it after the indentation, so each physical line becomes its
+            own single-line span */
+        let out = "";
+        let fence = 0;
+        let i = 0;
+        while (i < text.length) {
+            const ch = text[i];
+            if (ch === "`") {
+                /*  measure the full backtick run (a code-span delimiter is a
+                    *run* of backticks; a span opened by N backticks is closed
+                    only by a run of exactly N backticks)  */
+                let n = 0;
+                while (i < text.length && text[i] === "`") {
+                    n++;
+                    i++;
+                }
+                if (fence === 0)
+                    /*  open a span of fence width n  */
+                    fence = n;
+                else if (n === fence)
+                    /*  close the active span  */
+                    fence = 0;
+                out += "`".repeat(n);
+                continue;
+            }
+            if (fence > 0 && (ch === "\r" || ch === "\n")) {
+                /*  consume optional CR followed by mandatory LF  */
+                let nl = "";
+                if (ch === "\r" && i + 1 < text.length && text[i + 1] === "\n") {
+                    nl = "\r\n";
+                    i += 2;
+                }
+                else if (ch === "\n") {
+                    nl = "\n";
+                    i++;
+                }
+                else {
+                    /*  bare CR: not a recognized newline, pass through  */
+                    out += ch;
+                    i++;
+                    continue;
+                }
+                /*  consume the following run of SPACE/TAB whitespace  */
+                let ws = "";
+                while (i < text.length && (text[i] === " " || text[i] === "\t")) {
+                    ws += text[i];
+                    i++;
+                }
+                /*  close span before the break, re-open after indentation,
+                    preserving the active fence width on both sides  */
+                const bars = "`".repeat(fence);
+                out += `${bars}${nl}${ws}${bars}`;
+                continue;
+            }
+            out += ch;
+            i++;
+        }
+        /*  PASS 3: replace the leading "-"/"*" marker of every unordered
+            bullet paragraph with "◯", preserving the leading indentation
+            and the following whitespace; operate line-by-line so only the
+            actual list markers (at a line start) are affected  */
+        out = out
+            .split("\n")
+            .map((line) => line.replace(/^(\s*)[-*]([ \t]+)/, "$1◯$2"))
+            .join("\n");
+        return out;
+    }
+}
+/*  MCP registration entry point  */
+export class MarkdownMCP {
+    register(mcp) {
+        mcp.registerTool("ase_markdown_prepare", {
+            title: "ASE markdown prepare",
+            description: "Prepare Markdown `text` for improved rendering by rewriting " +
+                "unordered bullet paragraphs: replace the `-`/`*` bullet markers with `◯` " +
+                "and split multi-line inline code spans into per-line single-line spans. " +
+                "Single-backtick spans containing backslash-escaped backticks are rewritten " +
+                "into CommonMark-correct spans with a widened backtick fence and literal inner " +
+                "backticks. Returns the prepared Markdown as `text`.",
+            inputSchema: {
+                text: z.string()
+                    .describe("Markdown text to prepare for improved rendering")
+            }
+        }, async (args) => {
+            try {
+                const text = Markdown.prepare(args.text);
+                return {
+                    content: [{ type: "text", text }]
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `ERROR: ${message}` }]
+                };
+            }
+        });
+    }
+}

package/dst/ase-service.js

@@ -18,6 +18,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { Config, configSchema, ConfigMCP } from "./ase-config.js";
 import { DiagramMCP } from "./ase-diagram.js";
 import { TaskMCP } from "./ase-task.js";
+import { MarkdownMCP } from "./ase-markdown.js";
 import { ArtifactMCP } from "./ase-artifact.js";
 import { KVMCP } from "./ase-kv.js";
 import PersonaMCP from "./ase-persona.js";
@@ -237,6 +238,7 @@ export default class ServiceCommand {
             new ServiceMCP({ projectId: ctx.projectId, port: ctx.port, startTime }).register(mcp);
             new DiagramMCP().register(mcp);
             new TaskMCP(this.log).register(mcp);
+            new MarkdownMCP().register(mcp);
             new ArtifactMCP(this.log).register(mcp);
             new KVMCP().register(mcp);
             new PersonaMCP(this.log).register(mcp);

package/dst/ase-task.js

@@ -11,6 +11,7 @@ import picomatch from "picomatch";
 import { isScalar } from "yaml";
 import { z } from "zod";
 import { Config, configSchema, parseScope } from "./ase-config.js";
+import { Markdown } from "./ase-markdown.js";
 /*  reusable functionality: persisted task plans under
     <project>/<basedir>/TASK-<id>.md (driven by the
     "project.artifact.task.{basedir,files}" configuration)  */
@@ -420,7 +421,8 @@ export class TaskMCP {
             }
         }, async (args) => {
             try {
-                const text = Task.load(this.log, args.id);
+                const raw = Task.load(this.log, args.id);
+                const text = Markdown.prepare(raw);
                 return {
                     content: [{ type: "text", text }]
                 };
@@ -446,7 +448,8 @@ export class TaskMCP {
             }
         }, async (args) => {
             try {
-                Task.save(this.log, args.id, args.text);
+                const text = Markdown.prepare(args.text);
+                Task.save(this.log, args.id, text);
                 return {
                     content: [{ type: "text", text: `task_save: OK: saved task "${args.id}"` }]
                 };

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.6",
+    "version":                              "0.9.7",
     "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.60.1",
-        "@typescript-eslint/eslint-plugin": "8.60.1",
+        "@typescript-eslint/parser":        "8.61.0",
+        "@typescript-eslint/eslint-plugin": "8.61.0",
         "eslint-plugin-promise":            "7.3.0",
         "eslint-plugin-import":             "2.32.0",
         "neostandard":                      "0.13.0",
@@ -42,7 +42,7 @@
     },
     "dependencies": {
         "commander":                        "15.0.0",
-        "@dotenvx/dotenvx":                 "1.71.0",
+        "@dotenvx/dotenvx":                 "1.71.2",
         "yaml":                             "2.9.0",
         "valibot":                          "1.4.1",
         "execa":                            "9.6.1",
@@ -60,7 +60,7 @@
         "shell-quote":                      "1.8.4",
         "proper-lockfile":                  "4.1.2",
         "write-file-atomic":                "8.0.0",
-        "pacote":                           "21.5.0",
+        "pacote":                           "21.5.1",
         "ofetch":                           "1.5.1",
         "picomatch":                        "4.0.4"
     },

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

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

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

@@ -6,28 +6,28 @@ Every *task* uses a strict and fixed format:
 
 <format>
 
-# ✪ TASK <task-id/>: <title/>
+#   TASK <task-id/>: <title/>
 
-✳ Created:  **<timestamp-created/>**
-✎ Modified: **<timestamp-modified/>**
+Created:  <timestamp-created/>
+Modified: <timestamp-modified/>
 
-## ※ CONTEXT
+##  CONTEXT
 
-- **WHAT**: <summary-what/>
+-   **WHAT**: <summary-what/>
 
-- **WHY**: <summary-why/>
+-   **WHY**: <summary-why/>
 
-## ※ CHANGES
+##  CHANGES
 
-- [...]
+-   [...]
 
-- [...]
+-   [...]
 
-## ※ VERIFICATION
+##  VERIFICATION
 
-- [...]
+-   [...]
 
-- [...]
+-   [...]
 
 </format>
 
@@ -61,7 +61,7 @@ You *MUST* honor the following hints on this *task* format:
 -   The <title/> is a short summary of the <summary-what/>, no longer than
     50 characters.
 
--   The sections `※ CHANGES` and `※ VERIFICATION` all are just a short
+-   The sections `##  CHANGES` and `##  VERIFICATION` all are just a short
     list of 1-5 bullet points. Each bullet point is formatted as
     `- **<aspect/>**: <specification/>` where <aspect/> indicates
     the aspect of the section and <specification/> is 1-3 sentences
@@ -69,6 +69,6 @@ You *MUST* honor the following hints on this *task* format:
     description of the aspect.
 
 -   In all sections, break all lines with a newline character
-    after about 120 characters per line for better subsequent
+    after about 100 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.9.6",
+    "version":                              "0.9.7",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -19,7 +19,7 @@
         "markdownlint-cli2":                "0.22.1",
         "eslint":                           "10.4.1",
         "@eslint/markdown":                 "8.0.2",
-        "eslint-markdown":                  "0.10.0"
+        "eslint-markdown":                  "0.11.0"
     },
     "engines": {
         "npm":                              ">=10.0.0",

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

@@ -206,12 +206,12 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         inlining its pros/cons derived in sub-step 2:
 
         <template>
-        ● **APPROACH A<n/>**<annotation/>: *<summary/>*
-        ○ [...]
-        ○ [...]
-        ○ [...]
-        ⊕ *pro*: [...]
-        ⊖ *con*: [...]
+        ●   **APPROACH A<n/>**<annotation/>: *<summary/>*
+        ○   [...]
+        ○   [...]
+        ○   [...]
+        ⊕   *PRO*: [...]
+        ⊖   *CON*: [...]
         <optional-diagram/>
         </template>
 
@@ -278,7 +278,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         file, aligned with its existing style and conventions.
 
         <if condition="<getopt-option-dry/> is equal `true`">
-        You *MUST* completely omit the `## ※ VERIFICATION` section
+        You *MUST* completely omit the `##  VERIFICATION` section
         (including its heading and all of its bullet points) from
         <content/>.
         </if>

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

@@ -34,7 +34,7 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
     asking the user via the interactive dialog.
 
 `--dry`|`-d`:
-    Compose the plan *without* the `※ VERIFICATION` section. When
+    Compose the plan *without* the `##  VERIFICATION` section. When
     `ase-task-implement` later applies such a plan, it strictly skips
     the entire verification phase (no build, tests, linter,
     type-checker, or program execution) once the source files have
@@ -43,7 +43,7 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
 `--quick`|`-Q`:
     Shorthand alias for `-a -d -n IMPLEMENT,DELETE`: automatically pick
     the recommended feature approach, compose the plan *without* the
-    `※ VERIFICATION` section, immediately hand off to `ase-task-implement`,
+    `##  VERIFICATION` section, immediately hand off to `ase-task-implement`,
     and finally `ase-task-delete` the now-consumed plan. This gives a
     single, fast *one-shot* crafting mode.
 

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

@@ -196,12 +196,12 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         anything else in this step:
 
         <template>
-        ● **APPROACH A<n/>**<annotation/>: *<summary/>*
-        ○ [...]
-        ○ [...]
-        ○ [...]
-        ⊕ *pro*: [...]
-        ⊖ *con*: [...]
+        ●   **APPROACH A<n/>**<annotation/>: *<summary/>*
+        ○   [...]
+        ○   [...]
+        ○   [...]
+        ⊕   **PRO*: [...]
+        ⊖   **CON*: [...]
         <optional-diagram/>
         </template>
 
@@ -269,7 +269,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         file, aligned with its existing style and conventions.
 
         <if condition="<getopt-option-dry/> is equal `true`">
-        You *MUST* completely omit the `## ※ VERIFICATION` section
+        You *MUST* completely omit the `##  VERIFICATION` section
         (including its heading and all of its bullet points) from
         <content/>.
         </if>

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

@@ -34,7 +34,7 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
     asking the user via the interactive dialog.
 
 `--dry`|`-d`:
-    Compose the plan *without* the `※ VERIFICATION` section. When
+    Compose the plan *without* the `##  VERIFICATION` section. When
     `ase-task-implement` later applies such a plan, it strictly skips
     the entire verification phase (no build, tests, linter,
     type-checker, or program execution) once the source files have
@@ -43,7 +43,7 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
 `--quick`|`-Q`:
     Shorthand alias for `-a -d -n IMPLEMENT,DELETE`: automatically pick
     the recommended refactoring approach, compose the plan *without* the
-    `※ VERIFICATION` section, immediately hand off to `ase-task-implement`,
+    `##  VERIFICATION` section, immediately hand off to `ase-task-implement`,
     and finally `ase-task-delete` the now-consumed plan. This gives a
     single, fast *one-shot* refactoring mode.
 

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

@@ -245,12 +245,12 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         anything else in this step:
 
         <template>
-        ● **APPROACH A<n/>**<annotation/>: *<summary/>*
-        ○ [...]
-        ○ [...]
-        ○ [...]
-        ⊕ *pro*: [...]
-        ⊖ *con*: [...]
+        ●   **APPROACH A<n/>**<annotation/>: *<summary/>*
+        ○   [...]
+        ○   [...]
+        ○   [...]
+        ⊕   *PRO*: [...]
+        ⊖   *CON*: [...]
         <optional-diagram/>
         </template>
 
@@ -317,7 +317,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         file, aligned with its existing style and conventions.
 
         <if condition="<getopt-option-dry/> is equal `true`">
-        You *MUST* completely omit the `## ※ VERIFICATION` section
+        You *MUST* completely omit the `##  VERIFICATION` section
         (including its heading and all of its bullet points) from
         <content/>.
         </if>

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

@@ -39,7 +39,7 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
     asking the user via the interactive dialog.
 
 `--dry`|`-d`:
-    Compose the plan *without* the `※ VERIFICATION` section. When
+    Compose the plan *without* the `##  VERIFICATION` section. When
     `ase-task-implement` later applies such a plan, it strictly skips
     the entire verification phase (no build, tests, linter,
     type-checker, or program execution) once the source files have
@@ -48,7 +48,7 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
 `--quick`|`-Q`:
     Shorthand alias for `-a -d -n IMPLEMENT,DELETE`: automatically pick
     the recommended resolution approach, compose the plan *without* the
-    `※ VERIFICATION` section, immediately hand off to `ase-task-implement`,
+    `##  VERIFICATION` section, immediately hand off to `ase-task-implement`,
     and finally `ase-task-delete` the now-consumed plan. This gives a
     single, fast *one-shot* resolution mode.
 

package/plugin/skills/ase-task-edit/SKILL.md

@@ -73,7 +73,7 @@ that `CHANGELOG.md` file, aligned with its existing style
 and conventions.
 
 <if condition="<getopt-option-dry/> is equal `true`">
-You *MUST* completely omit the `## ※ VERIFICATION` section
+You *MUST* completely omit the `##  VERIFICATION` section
 (including its heading and all of its bullet points) from
 <content/>.
 </if>
@@ -318,11 +318,12 @@ Set <content-dirty>true</content-dirty>.
         </template>
         </if>
 
-    3.  *Render plan*: Only output the following <template/>, so the user
+    3.  *Render plan*: Treat <content/> as *verbatim* Markdown.
+        Only output the following <template/>, so the user
         can read the plan and react to it. If <content/> is longer
-        than 90 lines and a `※ IMPLEMENTATION DRAFT` section (from the
+        than 90 lines and a `##  IMPLEMENTATION DRAFT` section (from the
         companion skill `ase-task-preflight`) exists, replace the entire
-        content of the `※ IMPLEMENTATION DRAFT` section with `[...]`.
+        content of the `##  IMPLEMENTATION DRAFT` section with `[...]`.
         Else, do *not* truncate, summarize, or partially show the plan.
         Use the following <template/>:
 

package/plugin/skills/ase-task-edit/help.md

@@ -30,7 +30,7 @@ hand-off to implementation or preflight.
     ignoring *instruction* and stopping skill processing).
 
 `--dry`|`-d`:
-    Generate any *new* plan *without* the `※ VERIFICATION` section.
+    Generate any *new* plan *without* the `##  VERIFICATION` section.
     Applies only to freshly generated plans, not to existing plans
     loaded from disk. When `ase-task-implement` later applies such
     a plan, it strictly skips the entire verification phase (no

package/plugin/skills/ase-task-grill/SKILL.md

@@ -107,6 +107,11 @@ Procedure
     *essential aspect* of the task plan in <plan/> *until* reaching a
     shared understanding and no decisions/questions are left open.
 
+    This especially means, you *MUST* clarify as much aspects as
+    necessary to ensure that for at least the most important decisions,
+    during a subsequent implementation, no essential freedom of choices
+    exist any longer.
+
     For this process, determine the <n/> essential aspects <aspect-N/>
     (a one or two word long short identifier like `Foo` or `Bar-Baz`)
     and the corresponding decision/question <question-N/> where a shared
@@ -224,7 +229,8 @@ Procedure
     2.  Check the tool <result/> and dispatch accordingly:
 
         -   If <result/> is `DONE` or `CANCEL`:
-            Only output the following <template/> and then *STOP*.
+            Only output the following <template/> and then *STOP*,
+            without output of any further information.
 
             <template>
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- done**

package/plugin/skills/ase-task-implement/SKILL.md

@@ -131,8 +131,8 @@ explicitly requested by this procedure via outputs based on a <template/>!
         overrules the implementation draft in the `IMPLEMENTATION DRAFT`
         section of <content/>.
 
-        <if condition="<content/> does NOT contain a `## ※ VERIFICATION` section heading">
-        The task plan deliberately *omits* the `## ※ VERIFICATION`
+        <if condition="<content/> does NOT contain a `##  VERIFICATION` section heading">
+        The task plan deliberately *omits* the `##  VERIFICATION`
         section. You *MUST* therefore *strictly skip* the entire
         verification phase after modifying the source files: do *NOT*
         run any build, do *NOT* run any tests, do *NOT* run any linter,

package/plugin/skills/ase-task-implement/help.md

@@ -18,7 +18,7 @@ a task plan by modifying the corresponding *artifacts* with a complete
 section produced by `ase-task-preflight` is used as a hint - the plain
 plan content always overrules the draft.
 
-If the task plan deliberately *omits* the `※ VERIFICATION` section
+If the task plan deliberately *omits* the `##  VERIFICATION` section
 (as produced by `ase-code-craft`, `ase-code-refactor`,
 `ase-code-resolve`, or `ase-task-edit` when invoked with `--dry`),
 the entire verification phase is strictly skipped: no build, tests,

package/plugin/skills/ase-task-preflight/SKILL.md

@@ -126,13 +126,13 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
     2.  Append this artifact change set <unified-diff/> to the end
         of the <content/> with the following <template/>. If a section
-        named `## ※ IMPLEMENTATION DRAFT` already exists from a
+        named `##  IMPLEMENTATION DRAFT` already exists from a
         previous run of this skill, *replace* this entire existing
         section.
 
         <template>
 
-        ## ※ IMPLEMENTATION DRAFT
+        ##  IMPLEMENTATION DRAFT
 
         ```text
         <unified-diff/>