@rse/ase 0.0.44 → 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"]
@@ -50,10 +51,11 @@ export const projectClassificationPresets = {
     }
 };
 /*  hard-coded map: which scope kinds each variable may be SET on
-    (reads always cascade through the full chain, this restricts writes only);
+    (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

@@ -177,7 +177,7 @@ export default class HookCommand {
         #{@ase_agent_status} (refreshed on tmux's own interval,
         independent of Claude Code's statusline repaint cadence).
         Notice: the Claude Code statusline is not usable for this case
-        here at all, as it is not repainted during agent processing! */
+        at all, as it is not repainted during agent processing!  */
     writeAgentStatus(status) {
         const icon = status === "busy" ? "▶" : "⏸";
         if (process.env.TMUX !== undefined
@@ -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

@@ -6,7 +6,7 @@
 import { z } from "zod";
 import { ofetch } from "ofetch";
 import pacote from "pacote";
-/*  reusable functionality: gather per-package metadata in maximum parallel  */
+/*  reusable functionality: gather per-package metadata with maximum parallelism  */
 export class Skills {
     /*  HTTP timeout for the GitHub/npm-downloads side calls  */
     static HTTP_TIMEOUT_MS = 10_000;
@@ -75,50 +75,184 @@ export class Skills {
             return "N.A.";
         }
     }
-    /*  gather metadata for all given components in maximum parallel,
+    /*  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 in maximum parallel. " +
-                "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/dst/ase-statusline.js

@@ -481,7 +481,7 @@ export default class StatuslineCommand {
             /*  send output  */
             process.stdout.write(out);
             /*  optionally publish task id to the calling tmux pane as a per-pane user
-                option, so someone (like claudeX) can pick it up via #{@ase_task_id}  */
+                option, so something (like claudeX) can pick it up via #{@ase_task_id}  */
             if (process.env.TMUX !== undefined
                 && process.env.TMUX !== ""
                 && process.env.TMUX_PANE !== undefined

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.44",
+    "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.44",
+    "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.44",
+    "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 align 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 begin 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

@@ -19,7 +19,8 @@ Persona Ruleset Levels
     ("sure", "certainly", "of course", "happy to", etc).
 -   You *MUST* *drop* hedging
     ("I think", "maybe", "perhaps", "it seems", "sort of", "probably", "I'm not sure but...", "it might be", etc).
--   You *MUST* *prefer* bullet points with one or two sentences each, instead of long prose paragraphs.
+-   You *MUST* *prefer* lists with bullet points, instead of long prose paragraphs.
+-   You *MUST* *prefer* bullet points with one or two sentences.
 </define>
 
 ### Level 2
@@ -46,12 +47,12 @@ Persona Ruleset Levels
 -   You *MUST* *use* only one word, when one word is clear enough.
 -   You *MUST* *use* only two words, when two words are clear enough.
 -   You *MUST* *use* the three sentence patterns
-    (dependending what information has to be expressed):
+    (depending what information has to be expressed):
     -   `<subject/> <action/> <object/>, <reason/>.` → e.g. "Cat eats fish, hungry."
     -   `<subject/> <action/> <object/>.`            → e.g. "Dog chases ball."
     -   `<subject/> <action/>.`                      → e.g. "Birds fly."
--   You *MUST* *drop* even all bullet points and just
-    provide very short subsequent sentences.
+-   You *MUST* *drop* all lists and their bullet points and instead
+    provide very short subsequent sentences only.
 </define>
 
 Apply Persona
@@ -79,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"/>