@rse/ase 0.9.6 → 0.9.8

package/dst/ase-getopt.js

@@ -19,7 +19,9 @@ export class GetoptMCP {
                 "containing those remaining tokens (quotes preserved), and " +
                 "`info` is a markdown rendering of the parsed options in the " +
                 "form `key: **value**, key: **value**, ...` for printing at " +
-                "the top of a skill.",
+                "the top of a skill. Options whose long name starts with " +
+                "`int-` are treated as internal and are excluded from both " +
+                "the usage help and the `info` rendering.",
             inputSchema: {
                 name: z.string()
                     .describe("Name of the caller (e.g. skill name), used in error messages"),
@@ -53,6 +55,7 @@ export class GetoptMCP {
                 /*  tokenize spec and add one option per token  */
                 const tokens = args.spec.split(/\s+/).filter((e) => e.length > 0);
                 const re = /^--([A-Za-z][A-Za-z0-9-]*)(?:\|-([A-Za-z]))?(?:=(\((.*)\)(\.\.\.)?|.*))?$/;
+                const internals = new Set();
                 for (const tok of tokens) {
                     const m = re.exec(tok);
                     if (m === null)
@@ -76,6 +79,12 @@ export class GetoptMCP {
                     }
                     else
                         opt.default(false);
+                    if (long !== undefined && long.startsWith("int-")) {
+                        /*  internal option: hide from usage help and remember
+                            its camel-cased key for the info rendering below  */
+                        opt.hideHelp();
+                        internals.add(long.replace(/-(.)/g, (_, c) => c.toUpperCase()));
+                    }
                     cmd.addOption(opt);
                 }
                 /*  parse args  */
@@ -145,6 +154,7 @@ export class GetoptMCP {
                 /*  build markdown info rendering of parsed options  */
                 const opts = cmd.opts();
                 const info = Object.entries(opts)
+                    .filter(([k]) => !internals.has(k))
                     .map(([k, v]) => `${k}: **${shQuote([String(v)])}**`)
                     .join(", ");
                 /*  build result  */

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)  */
@@ -19,8 +20,8 @@ export class Task {
     static validateId(id) {
         if (typeof id !== "string" || id.length === 0)
             throw new Error("task: id must be a non-empty string");
-        if (!/^[A-Za-z0-9-]+$/.test(id))
-            throw new Error("task: id must match [A-Za-z0-9-]+");
+        if (!/^[A-Za-z0-9_-]+$/.test(id))
+            throw new Error("task: id must match [A-Za-z0-9_-]+");
     }
     /*  determine the project root (Git top-level if inside a Git
         working tree, otherwise the current working directory)  */
@@ -75,7 +76,7 @@ export class Task {
         if (!fs.existsSync(dir))
             return false;
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            if (!entry.isDirectory() || !/^[A-Za-z0-9-]+$/.test(entry.name))
+            if (!entry.isDirectory() || !/^[A-Za-z0-9_-]+$/.test(entry.name))
                 continue;
             if (fs.existsSync(path.join(dir, entry.name, "plan.md")))
                 return true;
@@ -148,7 +149,7 @@ export class Task {
         if (fs.existsSync(newFile))
             throw new Error(`task: target id "${newId}" already exists`);
         const text = fs.readFileSync(oldFile, "utf8");
-        const updated = text.replace(/(^#\s+(?:✪\s+)?TASK\s+)[A-Za-z0-9-]+(\s*:)/m, `$1${newId}$2`);
+        const updated = text.replace(/(^#\s+TASK\s+)[A-Za-z0-9_-]+(\s*:)/m, `$1${newId}$2`);
         fs.mkdirSync(path.dirname(newFile), { recursive: true });
         fs.writeFileSync(newFile, updated, "utf8");
         fs.rmSync(oldFile, { force: true });
@@ -167,7 +168,7 @@ export class Task {
         const isMatch = picomatch(files, { dot: true });
         const out = [];
         for (const entry of fs.readdirSync(dir)) {
-            const m = /^TASK-([A-Za-z0-9-]+)\.md$/.exec(entry);
+            const m = /^TASK-([A-Za-z0-9_-]+)\.md$/.exec(entry);
             if (m === null || !isMatch(entry))
                 continue;
             const file = path.join(dir, entry);
@@ -193,7 +194,7 @@ export class Task {
         const cutoff = Date.now() - maxAgeMs;
         const removed = [];
         for (const entry of fs.readdirSync(dir)) {
-            const m = /^TASK-([A-Za-z0-9-]+)\.md$/.exec(entry);
+            const m = /^TASK-([A-Za-z0-9_-]+)\.md$/.exec(entry);
             if (m === null || !isMatch(entry))
                 continue;
             const file = path.join(dir, entry);
@@ -416,11 +417,12 @@ export class TaskMCP {
                 "Returns the task as `text`; returns an empty string if no task exists for the `id`.",
             inputSchema: {
                 id: z.string()
-                    .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '-')")
+                    .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')")
             }
         }, 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 }]
                 };
@@ -440,7 +442,7 @@ export class TaskMCP {
                 "Overwrites any existing task for the same `id`.",
             inputSchema: {
                 id: z.string()
-                    .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '-')"),
+                    .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')"),
                 text: z.string()
                     .describe("text content of the task")
             }
@@ -448,7 +450,7 @@ export class TaskMCP {
             try {
                 Task.save(this.log, args.id, args.text);
                 return {
-                    content: [{ type: "text", text: `task_save: OK: saved task "${args.id}"` }]
+                    content: [{ type: "text", text: `OK: saved task "${args.id}"` }]
                 };
             }
             catch (err) {
@@ -466,14 +468,14 @@ export class TaskMCP {
                 "Returns a status `text` indicating whether a task existed and was removed.",
             inputSchema: {
                 id: z.string()
-                    .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '-')")
+                    .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')")
             }
         }, async (args) => {
             try {
                 const removed = Task.delete(this.log, args.id);
                 const msg = removed ?
-                    `task_delete: OK: removed task "${args.id}"` :
-                    `task_delete: WARNING: no task "${args.id}" to remove`;
+                    `OK: removed task "${args.id}"` :
+                    `WARNING: no task "${args.id}" to remove`;
                 return {
                     content: [{ type: "text", text: msg }]
                 };
@@ -494,16 +496,16 @@ export class TaskMCP {
                 "Fails with an error if the target id already exists.",
             inputSchema: {
                 old: z.string()
-                    .describe("old task identifier (allowed characters: A-Z, a-z, 0-9, '-')"),
+                    .describe("old task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')"),
                 new: z.string()
-                    .describe("new task identifier (allowed characters: A-Z, a-z, 0-9, '-')")
+                    .describe("new task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')")
             }
         }, async (args) => {
             try {
                 const renamed = Task.rename(this.log, args.old, args.new);
                 const msg = renamed ?
-                    `task_rename: OK: renamed task "${args.old}" to "${args.new}"` :
-                    `task_rename: WARNING: no task "${args.old}" to rename`;
+                    `OK: renamed task "${args.old}" to "${args.new}"` :
+                    `WARNING: no task "${args.old}" to rename`;
                 return {
                     content: [{ type: "text", text: msg }]
                 };
@@ -524,16 +526,16 @@ export class TaskMCP {
                 "otherwise it returns the current task `id` of the `session`.",
             inputSchema: {
                 id: z.string().optional()
-                    .describe("task identifier to set (allowed characters: A-Z, a-z, 0-9, '-'); " +
+                    .describe("task identifier to set (allowed characters: A-Z, a-z, 0-9, '_', '-'); " +
                     "if omitted, the current task id is returned"),
                 session: z.string()
-                    .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '-')")
+                    .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')")
             }
         }, async (args) => {
             try {
                 if (args.id !== undefined) {
                     Task.setId(this.log, args.session, args.id);
-                    const msg = `task_id: OK: set agent.task to "${args.id}" ` +
+                    const msg = `OK: set agent.task to "${args.id}" ` +
                         `for session "${args.session}"`;
                     return {
                         content: [{ type: "text", text: msg }]

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.8",
     "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",
@@ -30,7 +30,7 @@
         "nodemon":                          "3.1.14",
         "shx":                              "0.4.0",
 
-        "@types/node":                      "25.9.2",
+        "@types/node":                      "25.9.3",
         "@types/luxon":                     "3.7.1",
         "@types/which":                     "3.0.4",
         "@types/update-notifier":           "6.0.8",
@@ -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.8",
     "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.8",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/agents/ase-docs-proofread.md

@@ -62,9 +62,9 @@ Workflow
     6.  Set <context-after/> to exactly *up to two* lines of
         *unchanged* text content which occurs in the document
         directly *after* <old-text/>, i.e., the lines (<line/>
-        + <n/> + 1) and (<line/> + <n/> + 2), where <n/> is the
+        + <n/>) and (<line/> + <n/> + 1), where <n/> is the
         number of lines in <old-text/>. Reduce to just one line
-        (<line/> + <n/> + 1) if <old-text/> is the second-last
+        (<line/> + <n/>) if <old-text/> is the second-last
         line of the document. Set <context-after/> to empty if
         <old-text/> is the last line in the document.
 

package/plugin/meta/ase-constitution.md

@@ -16,6 +16,13 @@ you *MUST* once and immediately output the following <template/> now:
 ⧉ **ASE**: ☯ persona: **<ase-persona-style/>**
 </template>
 
+In case your harness instructions indicate that the user is shown
+only the *final* text message of each turn (e.g. *Claude Code* with
+"focus mode" enabled), you *MUST* ensure this <template/> output (and
+*every* <template/> output requested by ASE skills) lands in a final
+text message (after the last tool call of a turn) instead of between
+tool calls -- repeat it there if necessary.
+
 Prohibitions
 ------------
 

package/plugin/meta/ase-control.md

@@ -14,7 +14,7 @@ Control Flow Constructs
     Do not output anything.
 
 -   *IMPORTANT*: You *MUST* honor the following control flow construct:
-    <expand name="<define-name/>" [arg1="<expand-arg1/>" [arg2="<expand-arg2/>" [...]]]><expand-content/></expand>:
+    <expand name="<define-name/>" [arg1="<expand-arg1/>" [arg2="<expand-arg2/>" [...]]]>[<expand-content/>]</expand>:
 
     This specifies the *expansion* of previous <define/>. This
     construct is expanded to the <define-body/> of <define/> with
@@ -48,14 +48,35 @@ Control Flow Constructs
 
     This specifies a simple condition which is expanded to <if-body/>
     if <if-condition/> is met, or to empty string if <if-condition/> is
-    *not* met. Do not output anything else.
+    *not* met. It can be optionally followed by one or more <elseif/>
+    constructs and/or one final <else/> construct. Do not output anything else.
+
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <elseif condition="<elseif-condition/>"><elseif-body/></elseif>:
+
+    This specifies an *alternative condition* and has to directly
+    follow an <if/> or another <elseif/> construct. It is expanded
+    to <elseif-body/> if the conditions of all preceding <if/> and
+    <elseif/> constructs of the chain were *not* met and its own
+    <elseif-condition/> is met, or to the empty string otherwise.
+    Do not output anything else.
+
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <else><else-body/></else>:
+
+    This specifies the *fallback alternative* and has to directly
+    follow an <if/> or <elseif/> construct. It is expanded to
+    <else-body/> if the conditions of all preceding <if/> and
+    <elseif/> constructs of the chain were *not* met, or to the empty
+    string otherwise. Do not output anything else.
 
 -   *IMPORTANT*: You *MUST* honor the following control flow construct:
     <while condition="<while-condition/>"><while-body/></while>:
 
     This specifies a <while-body/> which is *repeated* as long as
     <while-condition/> is met. This construct is expanded to the
-    repetition of <while-body/>. Do not output anything else.
+    repetition of <while-body/>. A <break/> in <while-body/> can stop
+    the repetition early. Do not output anything else.
 
 -   *IMPORTANT*: You *MUST* honor the following control flow construct:
     <for items="<for-item/> [...]"><for-body/></for>:

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/meta/ase-getopt.md

@@ -28,7 +28,8 @@ set placeholders into the context as a side-effect.
     markdown rendering of the parsed options in the form `<longN/>:
     **<valueN/>**, [...]` (joined with `, `, with each value
     shell-quoted if value contains spaces or special characters, and
-    excluding the `help` option).
+    excluding the `help` option and any *internal* option whose long
+    name starts with `int-`).
 
     Then silently *SKIP* only the following steps 3-6
     and proceed directly to step 7 to display the results.