@rse/ase 0.0.46 → 0.0.48

package/dst/ase-config.js

@@ -13,6 +13,7 @@ import * as v from "valibot";
 import Table from "cli-table3";
 import writeFileAtomic from "write-file-atomic";
 import lockfile from "proper-lockfile";
+import { z } from "zod";
 /*  classification taxonomy  */
 export const projectClassification = {
     boxing: ["white", "grey", "black"]
@@ -53,7 +54,8 @@ export const projectClassificationPresets = {
     (reads always cascade through the full chain; this restricts writes only);
     keys absent from this map default to all non-"default" scope kinds  */
 export const configWritableScopes = {
-    "agent.task": ["session"]
+    "agent.task": ["session"],
+    "agent.skill": ["session"]
 };
 /*  default set of scope kinds writable for any unrestricted key  */
 const configWritableScopesDefault = ["user", "project", "task", "session"];
@@ -132,7 +134,8 @@ export const configSchema = v.nullish(v.strictObject({
     })),
     agent: v.optional(v.strictObject({
         persona: v.optional(v.picklist(agentClassification.persona)),
-        task: v.optional(v.pipe(v.string(), v.minLength(1)))
+        task: v.optional(v.pipe(v.string(), v.minLength(1))),
+        skill: v.optional(v.pipe(v.string(), v.minLength(1)))
     }))
 }));
 /*  encapsulate read/write access to a stack of "<name>.yaml" configuration files,
@@ -626,3 +629,100 @@ export default class ConfigCommand {
         });
     }
 }
+/*  MCP registration entry point for layered YAML configuration access  */
+export class ConfigMCP {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register the MCP tools  */
+    register(mcp) {
+        /*  config get  */
+        mcp.registerTool("config_get", {
+            title: "ASE config get",
+            description: "Read the effective value of a dotted configuration `key` from the layered " +
+                "configuration, cascading through default/user/project/task/session chain up to and " +
+                "including the requested `scope`. Returns the value as JSON-encoded `text`; " +
+                "returns an empty string if no value is set.",
+            inputSchema: {
+                key: z.string()
+                    .describe("dotted configuration key (e.g. \"agent.skill\")"),
+                scope: z.string()
+                    .describe("scope chain (e.g. \"session:<id>\", \"task:<id>\", \"project\", \"user\")")
+            }
+        }, async (args) => {
+            try {
+                const scope = parseScope(args.scope);
+                const cfg = new Config("config", configSchema, this.log, scope);
+                let text = "";
+                cfg.lock(() => {
+                    cfg.read();
+                    const val = cfg.get(args.key);
+                    text = val === undefined ? "" : JSON.stringify(val);
+                });
+                return { content: [{ type: "text", text }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { isError: true, content: [{ type: "text", text: `config_get: ERROR: ${message}` }] };
+            }
+        });
+        /*  config set  */
+        mcp.registerTool("config_set", {
+            title: "ASE config set",
+            description: "Write `val` to a dotted configuration `key` at the target `scope` " +
+                "(the strongest scope term in the chain). The value is validated against " +
+                "the configuration schema before being persisted.",
+            inputSchema: {
+                key: z.string()
+                    .describe("dotted configuration key (e.g. \"agent.skill\")"),
+                val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.any()), z.record(z.string(), z.any())])
+                    .describe("value to store under `key`"),
+                scope: z.string()
+                    .describe("scope chain (e.g. \"session:<id>\", \"task:<id>\", \"project\", \"user\")")
+            }
+        }, async (args) => {
+            try {
+                const scope = parseScope(args.scope);
+                const cfg = new Config("config", configSchema, this.log, scope);
+                cfg.lock(() => {
+                    cfg.read();
+                    cfg.set(args.key, args.val);
+                    cfg.write();
+                });
+                return { content: [{ type: "text", text: `config_set: OK: stored "${args.key}" on scope "${args.scope}"` }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { isError: true, content: [{ type: "text", text: `config_set: ERROR: ${message}` }] };
+            }
+        });
+        /*  config delete  */
+        mcp.registerTool("config_delete", {
+            title: "ASE config delete",
+            description: "Delete the value at a dotted configuration `key` from the target `scope` " +
+                "(the strongest scope term in the chain). No-op if the key is not present.",
+            inputSchema: {
+                key: z.string()
+                    .describe("dotted configuration key (e.g. \"agent.skill\")"),
+                scope: z.string()
+                    .describe("scope chain (e.g. \"session:<id>\", \"task:<id>\", \"project\", \"user\")")
+            }
+        }, async (args) => {
+            try {
+                const scope = parseScope(args.scope);
+                const cfg = new Config("config", configSchema, this.log, scope);
+                cfg.lock(() => {
+                    cfg.read();
+                    cfg.delete(args.key);
+                    cfg.write();
+                });
+                return { content: [{ type: "text", text: `config_delete: OK: removed "${args.key}" on scope "${args.scope}"` }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { isError: true, content: [{ type: "text", text: `config_delete: ERROR: ${message}` }] };
+            }
+        });
+    }
+}

package/dst/ase-getopt.js

@@ -34,7 +34,11 @@ export class GetoptMCP {
                 /*  normalize args  */
                 const argsRaw = typeof args.args === "string" ? args.args : null;
                 const argsVec = typeof args.args === "string" ?
-                    shParse(args.args).filter((e) => typeof e === "string") :
+                    shParse(args.args)
+                        .map((e) => typeof e === "string" ? e :
+                        (e !== null && typeof e === "object" && "op" in e && e.op === "glob" ?
+                            e.pattern : null))
+                        .filter((e) => e !== null) :
                     args.args;
                 /*  build a fresh commander program  */
                 const cmd = new Command(args.name)

package/dst/ase-hook.js

@@ -196,6 +196,26 @@ export default class HookCommand {
     /*  handler for "ase hook stop" (both tools)  */
     doStop(_tool) {
         this.writeAgentStatus("ready");
+        /*  safety net: clear any lingering "agent.skill" marker so a
+            crashed or aborted skill loop does not leave information active  */
+        const stdin = fs.readFileSync(0, "utf8");
+        const input = stdin.trim() !== "" ? JSON.parse(stdin) : {};
+        const sessionId = input.session_id ?? input.sessionId ?? "";
+        if (/^[A-Za-z0-9._-]+$/.test(sessionId)) {
+            try {
+                const cfg = new Config("config", configSchema, this.log, parseScope(`session:${sessionId}`));
+                cfg.lock(() => {
+                    cfg.read();
+                    if (typeof cfg.get("agent.skill") === "string") {
+                        cfg.delete("agent.skill");
+                        cfg.write();
+                    }
+                });
+            }
+            catch (_e) {
+                /*  best-effort: ignore failures  */
+            }
+        }
         return 0;
     }
     /*  handler for "ase hook session-end" (both tools)  */
@@ -218,6 +238,25 @@ export default class HookCommand {
         }
         return 0;
     }
+    /*  read the session-scoped "agent.skill" config value  */
+    readActiveSkill(sessionId) {
+        if (!/^[A-Za-z0-9._-]+$/.test(sessionId))
+            return "";
+        try {
+            const cfg = new Config("config", configSchema, this.log, parseScope(`session:${sessionId}`));
+            let val = "";
+            cfg.lock(() => {
+                cfg.read();
+                const v = cfg.get("agent.skill");
+                if (typeof v === "string")
+                    val = v;
+            });
+            return val;
+        }
+        catch (_e) {
+            return "";
+        }
+    }
     /*  handler for "ase hook pre-tool-use" (both tools)  */
     doPreToolUse(tool) {
         const spec = toolSpecs[tool];
@@ -254,6 +293,14 @@ export default class HookCommand {
             approve = true;
             reason = "ASE MCP tool invocation auto-approved";
         }
+        else if (toolName === "Edit") {
+            const sessionId = input.session_id ?? input.sessionId ?? "";
+            const activeSkill = this.readActiveSkill(sessionId);
+            if (activeSkill === "ase-docs-proofread") {
+                approve = true;
+                reason = `${activeSkill}: user already consented via AskUserQuestion`;
+            }
+        }
         /*  emit permission decision (or stay silent to defer to default flow).
             Claude Code expects the decision nested in "hookSpecificOutput";
             Copilot CLI expects flat top-level fields.  */

package/dst/ase-service.js

@@ -15,7 +15,7 @@ import prettyMs from "pretty-ms";
 import * as v from "valibot";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { Config, configSchema } from "./ase-config.js";
+import { Config, configSchema, ConfigMCP } from "./ase-config.js";
 import { DiagramMCP } from "./ase-diagram.js";
 import { TaskMCP } from "./ase-task.js";
 import { KVMCP } from "./ase-kv.js";
@@ -241,6 +241,7 @@ export default class ServiceCommand {
             new TimestampMCP().register(mcp);
             new GetoptMCP().register(mcp);
             new SkillsMCP().register(mcp);
+            new ConfigMCP(this.log).register(mcp);
             return mcp;
         };
         /*  listen to HTTP/REST endpoints  */

package/dst/ase-skills.js

@@ -75,50 +75,184 @@ export class Skills {
             return "N.A.";
         }
     }
+    /*  fetch Maven Central metadata for a single coordinate `groupId:artifactId`:
+        the Solr search endpoint provides the latest version + a `timestamp` (ms
+        epoch) of that release; a second `core=gav` query yields the earliest
+        known release, which we treat as the "created" date. The latest POM is
+        then downloaded directly from the repo to extract the SCM/project URL.  */
+    static async fetchMavenInfo(coord) {
+        const [groupId, artifactId] = coord.split(":", 2);
+        if (groupId === undefined || artifactId === undefined || groupId === "" || artifactId === "")
+            return { version: "", created: "", updated: "", repository: "" };
+        try {
+            const latest = await Skills.httpLimit(() => ofetch("https://search.maven.org/solrsearch/select" +
+                `?q=g:%22${encodeURIComponent(groupId)}%22+AND+a:%22${encodeURIComponent(artifactId)}%22` +
+                "&rows=1&wt=json", { timeout: Skills.HTTP_TIMEOUT_MS, ignoreResponseError: true }));
+            const doc = latest?.response?.docs?.[0];
+            const version = doc?.latestVersion ?? doc?.v ?? "";
+            const updated = typeof doc?.timestamp === "number" ? new Date(doc.timestamp).toISOString() : "";
+            /*  Maven Central caps `rows` at 20 and ignores client `sort`,
+                so paginate via `start=` to walk all versions, accumulate the
+                minimum timestamp client-side  */
+            const baseUrl = "https://search.maven.org/solrsearch/select" +
+                `?q=g:%22${encodeURIComponent(groupId)}%22+AND+a:%22${encodeURIComponent(artifactId)}%22` +
+                "&core=gav&rows=20&wt=json";
+            let firstTs;
+            let start = 0;
+            for (let page = 0; page < 50; page++) {
+                const chunk = await Skills.httpLimit(() => ofetch(`${baseUrl}&start=${start}`, { timeout: Skills.HTTP_TIMEOUT_MS, ignoreResponseError: true }));
+                const docs = chunk?.response?.docs ?? [];
+                for (const d of docs) {
+                    if (typeof d.timestamp === "number" && (firstTs === undefined || d.timestamp < firstTs))
+                        firstTs = d.timestamp;
+                }
+                start += docs.length;
+                const total = chunk?.response?.numFound ?? 0;
+                if (docs.length === 0 || start >= total)
+                    break;
+            }
+            const created = typeof firstTs === "number" ? new Date(firstTs).toISOString() : updated;
+            let repository = "";
+            if (version !== "") {
+                try {
+                    const pom = await Skills.httpLimit(() => ofetch(`https://repo1.maven.org/maven2/${groupId.replace(/\./g, "/")}` +
+                        `/${artifactId}/${version}/${artifactId}-${version}.pom`, { timeout: Skills.HTTP_TIMEOUT_MS, ignoreResponseError: true, responseType: "text" }));
+                    if (typeof pom === "string") {
+                        const scm = /<scm>[\s\S]*?<url>\s*([^<\s]+)\s*<\/url>[\s\S]*?<\/scm>/i.exec(pom);
+                        if (scm !== null)
+                            repository = scm[1];
+                        else {
+                            const url = /<project\b[\s\S]*?<url>\s*([^<\s]+)\s*<\/url>/i.exec(pom);
+                            if (url !== null)
+                                repository = url[1];
+                        }
+                    }
+                }
+                catch {
+                    repository = "";
+                }
+            }
+            return { version, created, updated, repository };
+        }
+        catch {
+            return { version: "", created: "", updated: "", repository: "" };
+        }
+    }
+    /*  fetch the "Used By" count from `mvnrepository.com` as a downloads proxy
+        for a Maven coordinate (Maven Central exposes no per-artifact download
+        counts). The label `Used By (NNK)` on the artifact landing page denotes
+        the number of other published artifacts depending on it. Note: the site
+        is fronted by *Cloudflare* and frequently serves a JS-challenge to
+        non-browser clients regardless of `User-Agent` (the block is driven by
+        TLS/HTTP2 fingerprinting, not headers). A realistic browser UA is
+        best-effort and degrades gracefully to `"N.A."` when blocked.  */
+    static async fetchMavenDownloads(coord) {
+        const [groupId, artifactId] = coord.split(":", 2);
+        if (groupId === undefined || artifactId === undefined || groupId === "" || artifactId === "")
+            return "N.A.";
+        try {
+            const html = await Skills.httpLimit(() => ofetch(`https://mvnrepository.com/artifact/${encodeURIComponent(groupId)}/${encodeURIComponent(artifactId)}`, {
+                timeout: Skills.HTTP_TIMEOUT_MS,
+                ignoreResponseError: true,
+                responseType: "text",
+                headers: {
+                    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+                        "AppleWebKit/537.36 (KHTML, like Gecko) " +
+                        "Chrome/131.0.0.0 Safari/537.36"
+                }
+            }));
+            if (typeof html !== "string")
+                return "N.A.";
+            const m = /Used\s+By\s*\(\s*([\d.,]+)\s*([KMB]?)\s*\)/i.exec(html);
+            if (m === null)
+                return "N.A.";
+            const base = parseFloat(m[1].replace(/,/g, ""));
+            const mult = m[2] === "K" ? 1_000 : m[2] === "M" ? 1_000_000 : m[2] === "B" ? 1_000_000_000 : 1;
+            const n = Math.round(base * mult);
+            return Number.isFinite(n) ? n : "N.A.";
+        }
+        catch {
+            return "N.A.";
+        }
+    }
     /*  gather metadata for all given components with maximum parallelism,
         dispatching on the technology stack:
         -   "JavaScript"/"TypeScript": NPM registry (pacote) + GitHub stars + npm-downloads
-        -   "Java"/"Kotlin"/"Unknown": not yet supported -- return empty result  */
+        -   "Java"/"Kotlin":           Maven Central + GitHub stars + mvnrepository.com "Used By"
+        -   "Unknown":                 not supported -- return empty result  */
     static async info(stack, components) {
-        /*  FIXME: currently just limited technology stack support  */
-        if (stack !== "JavaScript" && stack !== "TypeScript")
+        if (stack === "JavaScript" || stack === "TypeScript") {
+            /*  per package: kick off packument and downloads in parallel,
+                then stars as soon as the packument resolves; across packages
+                everything runs concurrently via Promise.all  */
+            const results = await Promise.all(components.map(async (name) => {
+                const packumentPromise = Skills.fetchPackument(name);
+                const downloadsPromise = Skills.fetchDownloads(name);
+                const starsPromise = packumentPromise.then((p) => Skills.fetchStars(p.repository));
+                const [p, downloads, stars] = await Promise.all([
+                    packumentPromise, downloadsPromise, starsPromise
+                ]);
+                const created = p.time.created ?? "";
+                const updated = p.version !== "" ? (p.time[p.version] ?? "") : "";
+                const rank = Skills.computeRank(downloads, stars, created, updated);
+                return {
+                    name,
+                    version: p.version,
+                    created,
+                    updated,
+                    repository: p.repository,
+                    stars,
+                    downloads,
+                    rank
+                };
+            }));
+            /*  sort by rank in descending order (best first)  */
+            results.sort((a, b) => b.rank - a.rank);
+            return results;
+        }
+        else if (stack === "Java" || stack === "Kotlin") {
+            /*  per coordinate: kick off Maven Central info and mvnrepository
+                downloads in parallel, then stars as soon as the POM-derived
+                repository is known; across coordinates everything runs
+                concurrently via Promise.all  */
+            const results = await Promise.all(components.map(async (name) => {
+                const infoPromise = Skills.fetchMavenInfo(name);
+                const downloadsPromise = Skills.fetchMavenDownloads(name);
+                const starsPromise = infoPromise.then((i) => Skills.fetchStars(i.repository));
+                const [i, downloads, stars] = await Promise.all([
+                    infoPromise, downloadsPromise, starsPromise
+                ]);
+                const rank = Skills.computeRank(downloads, stars, i.created, i.updated);
+                return {
+                    name,
+                    version: i.version,
+                    created: i.created,
+                    updated: i.updated,
+                    repository: i.repository,
+                    stars,
+                    downloads,
+                    rank
+                };
+            }));
+            /*  sort by rank in descending order (best first)  */
+            results.sort((a, b) => b.rank - a.rank);
+            return results;
+        }
+        else
             return [];
-        /*  per package: kick off packument and downloads in parallel,
-            then stars as soon as the packument resolves; across packages
-            everything runs concurrently via Promise.all  */
-        const results = await Promise.all(components.map(async (name) => {
-            const packumentPromise = Skills.fetchPackument(name);
-            const downloadsPromise = Skills.fetchDownloads(name);
-            const starsPromise = packumentPromise.then((p) => Skills.fetchStars(p.repository));
-            const [p, downloads, stars] = await Promise.all([
-                packumentPromise, downloadsPromise, starsPromise
-            ]);
-            const created = p.time.created ?? "";
-            const updated = p.version !== "" ? (p.time[p.version] ?? "") : "";
-            const rank = Skills.computeRank(downloads, stars, created, updated);
-            return {
-                name,
-                version: p.version,
-                created,
-                updated,
-                repository: p.repository,
-                stars,
-                downloads,
-                rank
-            };
-        }));
-        /*  sort by rank in descending order (best first)  */
-        results.sort((a, b) => b.rank - a.rank);
-        return results;
     }
     /*  compute composite rank score from weighted metrics:
         downloads x
         stars x
         ([lifespan =] (updated - created)) x
-        ([recentness =] exp(-(now - updated) / halfLife))  */
+        ([recentness =] exp(-(now - updated) / halfLife))
+        `"N.A."` factors are treated as neutral `1` so that stacks for which
+        a particular metric is structurally unavailable (e.g. Maven Central
+        exposes no per-artifact download counts) can still be ranked by the
+        remaining metrics, instead of collapsing the entire product to zero.  */
     static computeRank(downloads, stars, created, updated) {
-        const d = typeof downloads === "number" ? downloads : 0;
-        const s = typeof stars === "number" ? stars : 0;
+        const d = typeof downloads === "number" ? downloads : 1;
+        const s = typeof stars === "number" ? stars : 1;
         const cMs = created !== "" ? Date.parse(created) : NaN;
         const uMs = updated !== "" ? Date.parse(updated) : NaN;
         if (Number.isNaN(cMs) || Number.isNaN(uMs))
@@ -160,20 +294,26 @@ export class SkillsMCP {
     register(mcp) {
         mcp.registerTool("component_info", {
             title: "ASE component info",
-            description: "Gather metadata for a list of NPM packages with maximum parallelism. " +
-                "For each package, fetches the full registry packument via `pacote` " +
-                "(in-process, no `npm view` subprocess), the GitHub `stargazers_count` " +
+            description: "Gather metadata for a list of packages with maximum parallelism, " +
+                "dispatching on the technology `stack`. For `JavaScript`/`TypeScript`, " +
+                "components are NPM package names: fetches the full registry packument via " +
+                "`pacote` (in-process, no `npm view` subprocess), the GitHub `stargazers_count` " +
                 "from `api.github.com` (if the repository points to GitHub), and the " +
-                "last-month downloads from `api.npmjs.org`. Returns a JSON `text` array " +
-                "of `{ name, version, created, updated, repository, stars, downloads, rank }` " +
-                "objects, sorted in descending order by `rank`. Failures of " +
-                "individual side calls are isolated and reported as `\"N.A.\"` or empty " +
-                "string so every entry has the full shape.",
+                "last-month downloads from `api.npmjs.org`. For `Java`/`Kotlin`, components " +
+                "are Maven coordinates of the form `groupId:artifactId`: fetches the latest " +
+                "version + earliest/latest release timestamps from the Maven Central Solr " +
+                "search endpoint, the SCM/project URL from the latest POM at `repo1.maven.org`, " +
+                "GitHub stars (if applicable), and the \"Used By\" count from `mvnrepository.com` " +
+                "as the `downloads` proxy. Returns a JSON `text` array of " +
+                "`{ name, version, created, updated, repository, stars, downloads, rank }` " +
+                "objects, sorted in descending order by `rank`. Failures of individual side " +
+                "calls are isolated and reported as `\"N.A.\"` or empty string so every entry " +
+                "has the full shape.",
             inputSchema: {
                 stack: z.string()
                     .describe("Technology stack: \"JavaScript\", \"TypeScript\", \"Java\", \"Kotlin\", or \"Unknown\""),
                 components: z.array(z.string())
-                    .describe("List of package names to gather metadata for")
+                    .describe("List of package names (NPM) or Maven coordinates `groupId:artifactId` (Java/Kotlin)")
             }
         }, async (args) => {
             try {

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

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

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

package/plugin/meta/ase-constitution.md

@@ -18,14 +18,14 @@ you *MUST* once and immediately output the following <template/> now:
 Prohibitions
 ------------
 
-- Do *not* factor out (move) code into own functions without good reason, like necessary reusability.
-- Do *not* use braces around single statement blocks in "if" and "while" constructs unless the language requires them.
+- Do *not* factor out (move) code blocks into their own functions without good reason, such as necessary reusability.
+- Do *not* use braces around single-statement blocks in "if" and "while" constructs unless the language requires them.
 - Do *not* insist on early "return" in "if" blocks if an "else" block exists.
-- Do *not* remove any whitespaces in the code formatting -- keep whitespaces aligned with code base.
+- Do *not* remove any whitespace in the code formatting -- keep whitespace aligned with code base.
 - Do *not* show just partial code changes -- always show complete changes.
 - Do *not* produce any line which consists of just one or more space characters before the newline -- use just the newline.
 - Do *not* use semicolons where they are syntactically optional, except inside `for` clauses.
-- Do *not* split continuous chunks of code less than 100 lines into individual functions.
+- Do *not* split continuous chunks of code fewer than 100 lines into individual functions.
 - Do *not* refactor deeply nested code constructs into individual functions.
 - Do *not* answer with the "You're absolutely right", "You are
   absolutely right", "You're absolutely correct", or "You are absolutely
@@ -41,16 +41,16 @@ Commandments
 - Be very *pedantic* on code style.
 - Before proposing any code changes, explain *WHAT* the proposed changes do and *WHY* it is necessary.
 - Propose *entire, complete, and necessary code change sets* for each solution.
-- Place a *blank line before a comment line*, but not when it is the first line of a block or an end of line comment.
+- Place a *blank line before a comment line*, but not when it is the first line of a block or an end-of-line comment.
 - Keep code and comment *formatting exactly as in the existing code*.
 - Use *regular comments* `/*  [...]  */` instead of end-of-line comments `//  [...]`.
 - Use *two leading/trailing spaces within comments* as in `/*  [...]  */`.
-- Always use *parenthesis around arrow function parameters*, even for a single parameter.
+- Always use *parentheses around arrow function parameters*, even for a single parameter.
 - Make a line break before the keywords "else", "catch", and "finally".
 - Try to *vertically align similar operators* on consecutive, similar lines.
 - Place spaces after opening and before closing angle brackets and braces.
 - Use *double-quotes* (`"[...]"`) instead of single-quotes (`'[...]'`) for all strings.
-- Use K&R coding style with *opening braces* at end of lines and *closing braces* at the beginning of lines.
+- Use K&R coding style with *opening braces* at the end of lines and *closing braces* at the beginning of lines.
 - When a language has a *more strongly-typed variant*, prefer that
   variant (e.g., TypeScript over JavaScript, Python with type hints
   over untyped Python).

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 into the <define-body/> of <define/>

package/plugin/meta/ase-dialog.md

@@ -79,7 +79,7 @@ Let the *user interactively choose* an answer.
                 tool result `"<question-description/>"="<answer/>"`.
                 Set <result><answer/></result>.
                 If <result/> is then NOT one
-                the "label" values from <config/>, set
+                of the "label" values from <config/>, set
                 <result>OTHER: <result/></result>
                 (prefix result with "OTHER").
 
@@ -109,7 +109,7 @@ Let the *user interactively choose* an answer.
         2.  Call the `ask_user` tool of the agent harness with:
 
             `ask_user({
-                question: "<question-label>: <question-description/>",
+                question: "<question-label/>: <question-description/>",
                 allow_freeform: true,
                 choices: [
                     <config/>

package/plugin/meta/ase-persona.md

@@ -80,7 +80,7 @@ rules even if later skill rules say different:
     </if>
 
 -   <if condition="<ase-persona-style/> is 'caveman'">
-    -   You *MUST* use the terse, rough and stuttering communication style of a *caveman*.
+    -   You *MUST* use the terse, rough, and stuttering communication style of a *caveman*.
     -   Apply ruleset "level0": <expand name="level0"/>
     -   Apply ruleset "level1": <expand name="level1"/>
     -   Apply ruleset "level2": <expand name="level2"/>

package/plugin/meta/ase-plan.md

@@ -61,10 +61,10 @@ You *MUST* honor the following hints on this *task plan* format:
     50 characters.
 
 -   The sections `※ CHANGES` and `※ VERIFICATION` all are just a short
-    list of 1-5 bullet points. Each bullet points is formatted as
+    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
-    giving a *ultra precise* but also *ultra brief* and *ultra concise*
+    giving an *ultra precise* but also *ultra brief* and *ultra concise*
     description of the aspect.
 
 -   In all sections, break all lines with a newline character

package/plugin/meta/ase-skill.md

@@ -15,7 +15,7 @@ Skill Output
 -   *IMPORTANT*: *All* output is *exclusively* requested through
     <template/> sections. You *MUST* *NOT* output anything *EXCEPT* it
     is explicitly included in such a <template/> section. Especially,
-    you *MUST* *NOT* output any explanations on your own, except
+    you *MUST* *NOT* output any explanations on your own, unless
     explicitly requested.
 
 -   *IMPORTANT*: You *MUST* output all <template/> sections *EXACTLY* as provided
@@ -49,7 +49,7 @@ Skill Output
         padding, draw the top edge to that width, then keep every
         inner line (including annotations like `!`, `?`, `*`)
         within it. Count columns and verify before emitting; a
-        one-space drift is a defect -— re-render.
+        one-space drift is a defect — re-render.
 
 -   *IMPORTANT*: For *Findings* (problems, tradeoffs, warnings
     emitted by analysis skills):

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

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

@@ -170,7 +170,7 @@ interface quality, quality attributes, and architecture governance.
       races and shared mutable state is covered by SA17.)
     - **SA09 COHESION**: *strong cohesion* within each component —
       internal parts (functions, fields, methods) are *tightly
-      related*, *co-change*, and share data or behaviour; scattered
+      related*, *co-change*, and share data or behavior; scattered
       helpers that merely coexist by accident are flagged.
     - **SA10 EXTENSIBILITY**: components are *open for extension*
       (plugins, SPIs, hooks) but *closed for modification*.
@@ -266,7 +266,7 @@ interface quality, quality attributes, and architecture governance.
 
     - *Package-graph construction (SA19–SA21)*: parse each file's
       import (or equivalent language construct) statement, keep
-      only first-party packages within the analysed scope, and
+      only first-party packages within the analyzed scope, and
       persist two intermediate structures: the per-package
       incoming/outgoing class-edge map (drives SA20, SA21) and
       the per-package noun-token frequency table extracted from

package/plugin/skills/ase-arch-discover/SKILL.md

@@ -9,6 +9,7 @@ disable-model-invocation: false
 effort: medium
 allowed-tools:
     - "Bash(npm search --json *)"
+    - "Bash(curl -s https://search.maven.org/*)"
     - "Skill"
     - "Agent"
 ---
@@ -92,7 +93,7 @@ for the technology stack to *provide* the *needed functionality*
         official package name as <package-K/>, the latest version as
         <version-K/>, the stars as <stars-K/>, the created date as
         <created-K/>, the last updated date as <updated-K/>, the total
-        number of downloads in the last month is <downloads-K/>.
+        number of downloads in the last month as <downloads-K/>.
 
     -   If <stack/> is "JavaScript" or "TypeScript":
 
@@ -114,9 +115,19 @@ for the technology stack to *provide* the *needed functionality*
 
         -   Based on the essential keywords <keyword-L/> (L=1-M),
             use the `ase-meta-search` skill in a subagent to *generally*
-            discover an initial set of a maximum of 12 *Java packages*
+            discover an initial set of a maximum of 12 *Maven packages*
             <component-K/> and at least their real name <name-K/> and
-            their unique package names <package-K/>.
+            their unique Maven coordinates <package-K/> of the form
+            `groupId:artifactId`.
+
+        -   Use the shell command `curl -s 'https://search.maven.org/solrsearch/select?q=<keyword-1/>+<keyword-M/>&rows=12&wt=json'`
+            to *specifically* discover an additional set of a maximum
+            of 12 *Maven packages* <component-K/> and at least their
+            unique Maven coordinates <package-K/> (i.e. `<g/>:<a/>` from
+            each result document's `g` and `a` fields), based on the
+            essential keywords <keyword-L/> (L=1-M). Merge the results
+            into the already existing result set, but deduplicate
+            entries by Maven coordinate.
 
     -   Call the `component_info(stack: <stack/>, components:
         [ <package-1/>, ..., <package-N/> ])` tool of the `ase` MCP

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

@@ -37,7 +37,7 @@ related to a set of code quality aspects.
     </template>
 
     Then decide whether you detected *potential problems* which
-    *requires* a *code change* and *think* about this decision to be
+    *require* a *code change* and *think* about this decision to be
     sure it is *not* a false positive. Then choose one of the following
     cases:
 
@@ -183,8 +183,8 @@ related to a set of code quality aspects.
     </expand>
     </step>
 
-9.  <step id="A08 - COMPLICATENESS">
-    <expand name="linter" arg1="A08 - COMPLICATENESS">
+9.  <step id="A08 - COMPLICATEDNESS">
+    <expand name="linter" arg1="A08 - COMPLICATEDNESS">
     Check for complicated or cumbersome code constructs.
 
     Especially, check for unnecessarily difficult code constructs

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

@@ -206,7 +206,7 @@ permitted way to persist artifacts is via `task_save(...)`.
         -   **Origin Proximity**:
             Problems for *obvious, particular, or expected* errors
             *should* be handled *near the origin*. Problems for
-            *theoretical, fictive, or unexpected* errors, *should* be
+            *theoretical, fictive, or unexpected* errors *should* be
             handled more generally and in parent scopes.
 
 4.  **Find Problem Resolution Approaches**:

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

@@ -3,14 +3,16 @@ name: ase-docs-proofread
 argument-hint: "<docs-reference>"
 description: >
     Analyze the documents for spelling, punctuation, or grammar errors.
-    Use when the user wants to "spellcheck", "proofread", or "lint" a text or document.
+    Use when the user wants to "proofread" or "spellcheck" a document.
 user-invocable: true
 disable-model-invocation: false
-effort: high
+effort: medium
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
 Proofread Documentation
 =======================
@@ -19,6 +21,12 @@ Proofread Documentation
 Analyze the documents for spelling, punctuation, or grammar errors.
 </skill>
 
+<expand name="getopt"
+    arg1="ase-docs-proofread"
+    arg2="--auto|-a">
+    $ARGUMENTS
+</expand>
+
 <role>
 Your role is an experienced, *expert-level proofreader*, specialized in
 checking and correcting the *spelling*, *punctuation* and *grammar* of
@@ -26,93 +34,259 @@ documents.
 </role>
 
 <objective>
-*Analyze* the documents of $ARGUMENTS for problems in their *spelling*,
-*punctuation* or *grammar* and immediately correct all found problems.
+*Analyze* the documents of `<getopt-arguments/>` for problems in their
+*spelling*, *punctuation*, or *grammar* and propose corrections.
 </objective>
 
 <flow>
 
-1.  <step id="STEP 1: Investigation & Checking">
-    Investigate on the document base by using the `Read` tool to read all
-    referenced document files. For all contained texts in those files,
-    check the following problem types *ONLY*:
+1.  <step id="STEP 1: Investigation">
+
+    First, use the following <template/> to give a hint on this step:
+
+    <template>
+    &#x26AA; **PROOFREADING INVESTIGATION**
+    </template>
+
+    Then dispatch the investigation to a *sub-agent* via the `Agent`
+    tool so that *no* investigation details leak into the user-visible
+    transcript. The sub-agent performs the silent reading and checking;
+    only its final structured return value is consumed here.
+
+    Invoke the `Agent` tool *exactly once* with:
+
+    -   `subagent_type`: `general-purpose`
+    -   `description`: `Proofread Investigation`
+    -   `prompt`: a *self-contained* briefing, instructing the sub-agent to:
+
+        1.  Use the `Read` tool to read all document files referenced
+            by <getopt-arguments/>.
+
+        2.  Check the contained texts *only* for the following problem
+            types:
+
+            - **Spelling**
+            - **Punctuation**
+            - **Grammar**
+
+            Do *NOT* flag stylistic preferences, Markdown formatting
+            choices, code/identifiers, XML/template tags, technical
+            terms, intentional capitalization, list/heading style, or
+            anything inside fenced code blocks or backtick spans. Be
+            conservative — only report clear, objective errors.
 
-    - **Spelling**
-    - **Punctuation**
-    - **Grammar**
+            For each found problem:
 
-    You *MUST* collect *all* found problems into an internal list only,
-    and then set <problems/> to the value of this list.
+            -   Set <type/> to the string `SPELLING`, `PUNCTUATION`, or
+                `GRAMMAR`, indicating the problem type.
 
-    You *MUST* *NOT* propose document changes in this step 1.
-    You *MUST* *NOT* output anything in this step 1.
+            -   Set <file/> to the *relative* filename path of the document.
+                Set <line/> to the numeric 1-based line number in the
+                document.
+
+            -   Set <old-text/> to the lines of the old text which
+                should be changed. Set <new-text/> to the lines of the
+                new text which will be changed.
+
+            -   Set <description/> to an ultra-brief and concise
+                Markdown-formatted description of the problem with
+                a hint of what is wrong and why it is wrong. In
+                this description, mark up all referenced verbatim
+                words <words/> from <old-text/> or <new-text/> as
+                quoted strings containing monospaced text with
+                Markdown based on the following <template/>:
+                <template>"`<words/>`"</template>.
+
+            -   Set <context-before/> to exactly *up to two* lines of
+                *unchanged* text context which occurs in the document
+                directly *before* <old-text/>, i.e., the lines (<line/> -
+                2) and (<line/> - 1). Reduce to just one line (<line/> -
+                1) if <old-text/> is the second line of the document. Set
+                <context-before/> to empty if <old-text/> is the first line in
+                the document.
+
+            -   Set <context-after/> to exactly *up to two* lines of
+                *unchanged* text content which occurs in the document
+                directly *after* <old-text/> the lines (<line/> + <n/> + 1)
+                and (<line/> + <n/> + 2), 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 of the document. Set
+                <context-after/> to empty if <old-text/> is the last line in
+                the document.
+
+        3.  Return *exclusively* a single fenced JSON block (no prose,
+            no preamble, no summary) of the following shape:
+
+            ```json
+            [
+                {
+                    "type":           <type/>,
+                    "file":           <file/>,
+                    "line":           <line/>,
+                    "description":    <description/>,
+                    "context_before": <context-before/>,
+                    "old_text":       <old-text/>,
+                    "new_text":       <new-text/>,
+                    "context_after":  <context-after/>
+                },
+                [...]
+            ]
+            ```
+
+        4.  You *MUST* *NOT* propose, apply, or render any document
+            changes itself.
+
+    Parse the JSON array from the sub-agent's return value and set
+    <problems/> to that list.
+
+    You *MUST* *NOT* output anything at all in this step 1 beyond the
+    single `Agent` tool invocation.
     </step>
 
 2.  <step id="STEP 2: Summary">
+
     Use the following <template/> to give a summary of the detected
     problems in <problems/>:
 
     <template>
+    &#x26AA; **PROOFREADING SUMMARY**:
+
     | *Proofread Type* | *Proofread Result*      |
     | ---------------- | ----------------------- |
     | **SPELLING**:    | **<n/>** problems found |
     | **PUNCTUATION**: | **<m/>** problems found |
     | **GRAMMAR**:     | **<k/>** problems found |
+
     </template>
 
     Hints:
 
-    -   <n/> is the number of spelling problems in <problems/>
-    -   <m/> is the number of punctuation problems in <problems/>
-    -   <k/> is the number of grammar problems in <problems/>
+    -   <n/> is the number of problems with `type` equal to `SPELLING`    in <problems/>
+    -   <m/> is the number of problems with `type` equal to `PUNCTUATION` in <problems/>
+    -   <k/> is the number of problems with `type` equal to `GRAMMAR`     in <problems/>
+
     </step>
 
-3.  <step id="STEP 3: Details & Correction">
+3.  <step id="STEP 3: Correction">
+
+    1.  You *MUST* activate the auto-approve gate for the `Edit` tool
+        by setting the session-scoped `agent.skill` configuration value
+        to this skill's name via the MCP tool call `config_set(key:
+        "agent.skill", val: "ase-docs-proofread", scope:
+        "session:<ase-session-id/>")` of the `ase` service.
+
+    2.  Iterate over all problems:
+
+        <for items="<problems/>">
+
+        1.  Set <type/>           to the `type` field of <item/>.
+            Set <file/>           to the `file` field of <item/>.
+            Set <line/>           to the `line` field of <item/>.
+            Set <description/>    to the `description` field of <item/>.
+            Set <context-before/> to the `context_before` field of <item/>.
+            Set <old-text/>       to the `old_text` field of <item/>.
+            Set <new-text/>       to the `new_text` field of <item/>.
+            Set <context-after/>  to the `context_after` field of <item/>.
+
+        2.  Report the problem with the following <template/>:
+
+            <template>
+            &#x1F7E0; **<type/> PROBLEM**: `<file/>`:<line/>:
+
+            <description/>
+            </template>
+
+        3.  <if condition="<getopt-option-auto/> is not 'true'">
+
+            Render the proposed correction as a *unified diff* with *one*
+            line of context in a fenced block based on the following <template/>:
+
+            <template>
+
+            &#x1F535; **<type/> CORRECTION**:
+
+            ```diff
+            --- <file/> (original)
+            +++ <file/> (corrected)
+            @@ -<line/>,<n/> +<line/>,<m/> @@
+             <context-before/>
+            -<old-text/>
+            +<new-text/>
+             <context-after/>
+            ```
+
+            </template>
+
+            Hints:
+            -   The <n/> is the number of lines in <old-text/>.
+            -   The <m/> is the number of lines in <new-text/>.
+
+            </if>
+
+        4.  <if condition="<getopt-option-auto/> is not 'true'">
+
+            Ask the user how to proceed via an interactive user dialog:
+
+            <expand name="user-dialog">
+                CORRECTION: How would you like to proceed with this proposed correction?
+                ACCEPT: Apply the proposed correction.
+                REFINE: Discard this proposed correction and generate a new one.
+                REJECT: Skip this proposed correction.
+            </expand>
+
+            </if>
+
+            <if condition="<getopt-option-auto/> is 'true'">
+
+            Set <result>ACCEPT</result>.
+
+            </if>
+
+        5.  Check <result/> and dispatch accordingly:
 
-    <for items="<problems/>">
+            -   <if condition="<result/> is 'ACCEPT'">
 
-    For the current <item/> from the collected list <problems/>, do the
-    following:
+                Invoke the `Edit` tool to apply the change exactly as shown
+                in the diff. The operation will be auto-approved because of
+                the active proofread marker, so *no* interactive permission
+                prompt will appear. Then continue with the next <item/>.
 
-    1.  Report the problem with the following <template/>:
+                </if>
 
-        <template>
-        &#x1F7E0; **<type/>**: [`<file/>`:<line/>]: <description/>
-        </template>
+            -   <if condition="
+                    <result/> starts with 'REFINE' or
+                    <result/> starts with 'OTHER'
+                ">
 
-        Hints:
+                Generate a *new* proposal for the *same* <item/>
+                (incorporating the user's free-text hint from <result/> if
+                provided via the "OTHER" prefix) and loop back to substep 2
+                of this iteration. There is *no* cap on refinement rounds —
+                keep refining until the user picks `ACCEPT` or `REJECT`.
 
-        -   The <type/> is `SPELLING`, `PUNCTUATION` or `GRAMMAR`
-            of <item/>.
+                </if>
 
-        -   The <file/> is the name of the document artifact of <item/>.
-            The <line/> is the line number of the document artifact of <item/>.
+            -   <if condition="
+                    <result/> is 'REJECT' or
+                    <result/> is 'CANCEL' or
+                    <result/> starts with 'ERROR'
+                ">
 
-        -   The <description/> is an ultra brief and concise description
-            of the problem <item/> with a hint what is wrong and why
-            it is wrong. In <description/>, markup all verbatim words
-            <words/> related to the checked text (or the proposed
-            corrected text) as quoted strings containing monospaced text
-            with the Markdown <template>"`<words/>`"</template>.
+                Skip this <item/> without any `Edit` call and continue
+                with the next <item/>.
 
-    2.  Propose a direct change to the corresponding document via the
-        interactive `Edit` tool.
+                </if>
 
-        **IMPORTANT**: Regardless of whether the change was *accepted*
-        or *rejected* by the user (i.e., even if the `Edit` tool returns
-        an error like "The user doesn't want to proceed with this tool
-        use" or "User rejected"), you *MUST* immediately *CONTINUE* with
-        the *next* <item/> in the iteration.
+        </for>
 
-        Do *NOT* stop. Do *NOT* ask the user for confirmation. Do *NOT*
-        summarize. A rejection is *NOT* a signal to abort; it is only
-        a signal that *this one* change is skipped. Only after *all*
-        problems have been processed may you stop.
+    3.  After the iteration has finished, you *MUST* clear the auto-approve
+        gate via the call MCP tool call `config_delete(key:
+        "agent.skill", scope: "session:<ase-session-id/>")` of the `ase`
+        service.
 
-    </for>
+    4.  You *MUST* *NOT* output any further additional explanations or
+        summaries at the end of this skill processing.
 
-    You *MUST* *NOT* output any further additional explanations or
-    summaries at the end of this skill processing.
     </step>
 
 </flow>

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

@@ -66,7 +66,7 @@ are also grouped and sorted according to the above <prefix/>es.
    </step>
 
 3. <step id="STEP 3: Complete ChangeLog entries">
-   Without immediately modifying `CHANGELOG.md` file,
+   Without immediately modifying the `CHANGELOG.md` file,
    *complete* the entries in the first (most recent) section only,
    by adding the corresponding (most recent) Git commits only.
    For each Git commit, reduce the Git commit messages to a single
@@ -74,17 +74,17 @@ are also grouped and sorted according to the above <prefix/>es.
    </step>
 
 4. <step id="STEP 4: Consolidate ChangeLog entries">
-   Without immediately modifying `CHANGELOG.md` file,
+   Without immediately modifying the `CHANGELOG.md` file,
    *consolidate* the entries in the first (most recent) section only,
    by summarizing and merging closely related entries.
    Perform the entry consolidation per prefix group only.
-   If a changelog <summary/> is too short or is too little comprehensible
+   If a changelog <summary/> is too short or is not comprehensible enough
    because of too little context, add some context, especially references
    to the class/module/package, etc.
    </step>
 
 5. <step id="STEP 5: Sort ChangeLog entries">
-   Without immediately modifying `CHANGELOG.md` file,
+   Without immediately modifying the `CHANGELOG.md` file,
    *sort* the entries in the first (most recent) section only.
    Instead of the chronological commit order, group the entries
    by the prefixes.

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

@@ -5,9 +5,9 @@ description: >
     *Always use* when you have to *visualize*
     structure/layout/components/dependencies as Flowchart,
     control-flow/branching/concurrency as Flowchart,
-    state-machine/states/transitions as an UML State Diagram,
-    data-flow/actors/messages/protocols as an UML Sequence Diagram,
-    data-structure/classes/methods as an UML Class Diagram,
+    state-machine/states/transitions as a UML State Diagram,
+    data-flow/actors/messages/protocols as a UML Sequence Diagram,
+    data-structure/classes/methods as a UML Class Diagram,
     data-model/entities/relationships as an ER Diagram, or
     metrics/distributions/time-series as XY-Charts.
 user-invocable: false
@@ -71,7 +71,7 @@ Rules
     In other words, after the `diagram` tool call completes, the
     skill *MUST* copy the tool's `text` result *verbatim* into a
     Markdown-fenced code block (triple backticks), directly placed
-    in the response text immediately after the MCP tool call -— the
+    in the response text immediately after the MCP tool call — the
     user reads the Markdown fenced block in the response, not the
     (truncated) tool call display. Emitting only the tool call without
     the reproduction of the `text` output is a defect: the diagram is
@@ -95,7 +95,7 @@ Rules
     For *comparison diagrams* (e.g., *current vs. proposed*, *before
     vs. after*), render each side as a *separate* Mermaid diagram
     specification via the `diagram` tool from the `ase` MCP service, and
-    then stack the two rendered blocks *vertically* -— each preceded by
+    then stack the two rendered blocks *vertically* — each preceded by
     a bold label (`**BEFORE:**` / `**AFTER:**`, or similar). Do *not*
     attempt side-by-side layout.
 

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

@@ -121,7 +121,7 @@ multi-*criteria* decision matrix.
         important, over normal, to less important). Do not output anything.
 
     -   Ensure the final number of criteria is always within the range of
-        minimum 8 and maximum 12: if less than 8 criteria were requested,
+        minimum 8 and maximum 12: if fewer than 8 criteria were requested,
         use the set of alternatives to decide on additional criteria
         which potentially allow best to triage the alternatives, take the
         <reason/> into account, and use the `ase-meta-search` skill (drawing from