@rse/ase 0.0.49 → 0.0.51

package/dst/ase-hook.js

@@ -147,6 +147,7 @@ export default class HookCommand {
         const taskId = process.env.ASE_TASK_ID ?? "default";
         if (hasSession)
             cfg.lock(() => {
+                cfg.read();
                 cfg.set("agent.task", taskId);
                 cfg.write();
             });

package/dst/ase-setup.js

@@ -8,6 +8,9 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { execa } from "execa";
 import which from "which";
+import * as dotenvx from "@dotenvx/dotenvx";
+import Table from "cli-table3";
+import chalk from "chalk";
 import Version from "./ase-version.js";
 const toolSpecs = {
     "claude": { cli: "claude", label: "Claude Code" },
@@ -96,7 +99,8 @@ export default class SetupCommand {
     /*  run a sub-process, suppressing output on success and emitting it on failure  */
     async run(cmd, args, opts = {}) {
         const { cwd, quiet = false, retries = 1, ignoreError } = opts;
-        this.log.write("info", `setup: $ ${cmd} ${args.join(" ")}` +
+        const argsLog = args.map((arg) => arg.replace(/(_KEY=)(\S+)/, (_, k, v) => k + "*".repeat(v.length)));
+        this.log.write("info", `setup: $ ${cmd} ${argsLog.join(" ")}` +
             (cwd !== undefined ? ` (cwd: ${cwd})` : ""));
         for (let i = 0; i < retries; i++) {
             const final = (i === retries - 1);
@@ -240,6 +244,416 @@ export default class SetupCommand {
         }
         return 0;
     }
+    /*  handler for "ase setup mcp list"  */
+    async doMcpList() {
+        const table = new Table({
+            head: ["ID", "NAME", "VERS", "MCP", "KEY", "SKILLS"],
+            colWidths: [16, 16, 8, 21, 17, 20],
+            wordWrap: true,
+            chars: { "mid": "", "left-mid": "", "mid-mid": "", "right-mid": "" },
+            style: { head: ["blue"] }
+        });
+        for (const handle of this.mcpServers)
+            table.push([
+                chalk.bold(handle.id),
+                handle.name,
+                handle.version ?? "(unknown)",
+                handle.server,
+                handle.env.join(", "),
+                handle.skills.join(", ")
+            ]);
+        process.stdout.write(`${table.toString()}\n`);
+        return 0;
+    }
+    /*  handler for "ase setup mcp activate|deactivate [<servers>]"  */
+    async doMcp(action, tool, servers) {
+        await this.ensureTool(toolSpecs[tool].cli);
+        /*  source .env files into the environment so the per-server
+            API keys (ASE_MCP_KEY_<XXX>) can live in a .env file instead
+            of the exported interactive shell environment  */
+        dotenvx.config({ quiet: true, ignore: ["MISSING_ENV_FILE"] });
+        /*  resolve the comma-separated list of server ids, with an empty
+            list or the literal "all" expanding to every registered server
+            id; track whether the ids were explicitly given on the CLI  */
+        const known = this.mcpServers.map((handle) => handle.id);
+        const explicit = servers.trim() !== "" && servers.trim() !== "all";
+        const ids = explicit ?
+            servers.split(",").map((s) => s.trim()).filter((s) => s !== "") : known;
+        for (const id of ids)
+            if (this.mcpServers.find((handle) => handle.id === id) === undefined)
+                throw new Error(`unknown MCP server "${id}" ` +
+                    `(known: ${known.join(", ")})`);
+        /*  dispatch each selected server to its dedicated handler  */
+        for (const id of ids) {
+            /*  find handle  */
+            const handle = this.mcpServers.find((handle) => handle.id === id);
+            /*  determine information and action  */
+            let envKey = "";
+            let envVal = "";
+            if (action === "activate") {
+                /*  on activation, require at least one of the per-server API
+                    key environment variables (ASE_MCP_KEY_<XXX>) to
+                    be set; skip the server when its id was only
+                    implicitly selected (empty list or "all"), but fail
+                    hard when it was given explicitly on the CLI  */
+                envKey = handle.env.find((name) => (process.env[`ASE_MCP_KEY_${name}`] ?? "") !== "") ?? "";
+                if (envKey === "") {
+                    const vars = handle.env.map((name) => `ASE_MCP_KEY_${name}`).join(", ");
+                    if (explicit)
+                        throw new Error(`none of ${vars} set: ` +
+                            `cannot activate MCP server "${handle.server}"`);
+                    this.log.write("info", `setup: mcp: activate: [${id}]: none of ${vars} set: ` +
+                        `skipping MCP server "${handle.server}" (${handle.name})`);
+                    continue;
+                }
+                envVal = process.env[`ASE_MCP_KEY_${envKey}`] ?? "";
+            }
+            /*  probe whether the MCP server is currently registered with the tool  */
+            const installed = await this.mcpInstalled(tool, handle.server);
+            if (action === "activate") {
+                /*  on activation, remove a stale registration first so the
+                    handler can re-create it cleanly  */
+                if (installed) {
+                    this.log.write("info", `setup: mcp: activate: [${id}]: MCP server "${handle.server}" ` +
+                        "already registered: removing stale registration first");
+                    await this.mcpRemove(tool, handle.server);
+                }
+            }
+            else if (!installed) {
+                /*  on deactivation, skip the removal of an absent server  */
+                this.log.write("info", `setup: mcp: deactivate: [${id}]: MCP server "${handle.server}" ` +
+                    "not registered: skipping removal");
+                continue;
+            }
+            /*  call the handler  */
+            this.log.write("info", `setup: mcp: ${action}: [${id}]: MCP server "${handle.server}" ` +
+                `(name: ${handle.name}${handle.version ? (", version: " + handle.version) : ""})`);
+            await handle.handler(handle, tool, action, envKey, envVal);
+        }
+        return 0;
+    }
+    /*  probe whether an MCP server is currently registered with the tool
+        by inspecting the exit code of "<cli> mcp get <name>"  */
+    async mcpInstalled(tool, name) {
+        const result = await execa(toolSpecs[tool].cli, ["mcp", "get", name], { stdio: "ignore", reject: false });
+        return result.exitCode === 0;
+    }
+    /*  register an MCP server with the tool, supporting both the "stdio"
+        (a local subprocess command) and "http" (a remote URL, optionally
+        with HTTP headers) transports; the per-tool command line differs
+        between Claude Code and GitHub Copilot CLI  */
+    async mcpAdd(tool, name, env, transport) {
+        const args = ["mcp", "add"];
+        if (tool === "claude") {
+            args.push("--scope", "user");
+            args.push("--transport", transport.type);
+            if (transport.type === "stdio") {
+                for (const [key, val] of Object.entries(env))
+                    args.push("-e", `${key}=${val}`);
+                args.push("--", name, ...transport.command);
+            }
+            else {
+                for (const [key, val] of Object.entries(transport.headers ?? {}))
+                    args.push("--header", `${key}: ${val}`);
+                args.push(name, transport.url);
+            }
+        }
+        else {
+            /*  GitHub Copilot CLI implies the stdio transport when the
+                command is provided after "--"; only "http"/"sse" servers
+                need an explicit "--transport" flag and take the URL as a
+                positional argument  */
+            if (transport.type === "stdio") {
+                args.push(name);
+                for (const [key, val] of Object.entries(env))
+                    args.push("--env", `${key}=${val}`);
+                args.push("--", ...transport.command);
+            }
+            else {
+                args.push("--transport", "http");
+                for (const [key, val] of Object.entries(transport.headers ?? {}))
+                    args.push("--header", `${key}: ${val}`);
+                args.push(name, transport.url);
+            }
+        }
+        await this.run(toolSpecs[tool].cli, args);
+    }
+    /*  unregister an MCP server from the tool; the per-tool command line
+        differs between Claude Code and GitHub Copilot CLI  */
+    async mcpRemove(tool, name) {
+        const args = tool === "claude" ?
+            ["mcp", "remove", "--scope", "user", name] :
+            ["mcp", "remove", name];
+        await this.run(toolSpecs[tool].cli, args, { ignoreError: `MCP server "${name}" not registered` });
+    }
+    /*  registry of pre-defined MCP servers: maps each server id onto its
+        dedicated handler which performs the activate/deactivate operation  */
+    mcpServers = [
+        {
+            id: "openai-chatgpt",
+            name: "OpenAI ChatGPT",
+            version: "5.5",
+            env: ["OPENAI_CHATGPT", "OPENROUTER"],
+            server: "chat-openai-chatgpt",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "openai/gpt-5.5"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://api.openai.com/v1",
+                                "--openai-api", "responses",
+                                "--openai-model", "gpt-5.5"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "google-gemini",
+            name: "Google Gemini",
+            version: "3.5",
+            env: ["GOOGLE_GEMINI", "OPENROUTER"],
+            server: "chat-google-gemini",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "google/gemini-3.5-flash"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://generativelanguage.googleapis.com/v1beta/openai/",
+                                "--openai-api", "completion",
+                                "--openai-model", "gemini-3.5-flash"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "deepseek",
+            name: "DeepSeek",
+            version: "4.0",
+            env: ["DEEPSEEK", "OPENROUTER"],
+            server: "chat-deepseek",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio",
+                            command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "deepseek/deepseek-v4-flash"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://api.deepseek.com/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "deepseek-v4-flash"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "xai-grok",
+            name: "xAI Grok",
+            version: "4.3",
+            env: ["XAI_GROK", "OPENROUTER"],
+            server: "chat-xai-grok",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "x-ai/grok-4.3"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://api.x.ai/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "grok-4.3"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "alibaba-qwen",
+            name: "Alibaba Qwen",
+            version: "3.7",
+            env: ["ALIBABA_QWEN", "OPENROUTER"],
+            server: "chat-alibaba-qwen",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "qwen/qwen3.7-max"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://dashscope.aliyuncs.com/compatible-mode/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "qwen3.7-max"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "zai-glm",
+            name: "Z.AI GLM",
+            version: "5.1",
+            env: ["ZAI_GLM", "OPENROUTER"],
+            server: "chat-zai-glm",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "z-ai/glm-5.1"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://api.z.ai/api/paas/v4/",
+                                "--openai-api", "completion",
+                                "--openai-model", "glm-5.1"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "brave",
+            name: "Brave",
+            version: "latest",
+            env: ["BRAVE"],
+            server: "search-brave",
+            skills: ["ase-meta-search", "ase-meta-evaluate", "ase-arch-discover"],
+            handler: async (spec, tool, action, _envKey, envVal) => {
+                if (action === "activate")
+                    await this.mcpAdd(tool, spec.server, {
+                        "BRAVE_API_KEY": envVal,
+                        "BRAVE_MCP_ENABLED_TOOLS": "brave_web_search"
+                    }, { type: "stdio", command: ["npx", "-y", "@brave/brave-search-mcp-server"] });
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "perplexity",
+            name: "Perplexity",
+            version: "latest",
+            env: ["PERPLEXITY"],
+            server: "search-perplexity",
+            skills: ["ase-meta-search", "ase-meta-evaluate", "ase-arch-discover"],
+            handler: async (spec, tool, action, _envKey, envVal) => {
+                if (action === "activate")
+                    await this.mcpAdd(tool, spec.server, {
+                        "PERPLEXITY_API_KEY": envVal
+                    }, { type: "stdio", command: ["npx", "-y", "@perplexity-ai/mcp-server"] });
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "exa",
+            name: "Exa",
+            version: "latest",
+            env: ["EXA"],
+            server: "search-exa",
+            skills: ["ase-meta-search", "ase-meta-evaluate", "ase-arch-discover"],
+            handler: async (spec, tool, action, _envKey, envVal) => {
+                if (action === "activate")
+                    await this.mcpAdd(tool, spec.server, {}, { type: "http", url: `https://mcp.exa.ai/mcp?exaApiKey=${envVal}` });
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        }
+    ];
     /*  parse and validate the --tool option  */
     parseTool(value) {
         if (value !== "claude" && value !== "copilot")
@@ -306,5 +720,36 @@ export default class SetupCommand {
             .action(async (opts) => {
             process.exit(await this.doDisable(this.parseTool(opts.tool)));
         });
+        /*  register CLI sub-command "ase setup mcp"  */
+        const mcpCmd = setupCmd
+            .command("mcp")
+            .description("activate or deactivate pre-defined MCP servers for a tool")
+            .action(() => {
+            mcpCmd.outputHelp();
+            process.exit(1);
+        });
+        /*  register CLI sub-command "ase setup mcp list"  */
+        mcpCmd
+            .command("list")
+            .description("list all available pre-defined MCP server names")
+            .action(async () => {
+            process.exit(await this.doMcpList());
+        });
+        /*  register CLI sub-command "ase setup mcp activate"  */
+        mcpCmd
+            .command("activate [servers]")
+            .description("activate pre-defined MCP servers (comma-separated list, or \"all\")")
+            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .action(async (servers, opts) => {
+            process.exit(await this.doMcp("activate", this.parseTool(opts.tool), servers ?? "all"));
+        });
+        /*  register CLI sub-command "ase setup mcp deactivate"  */
+        mcpCmd
+            .command("deactivate [servers]")
+            .description("deactivate pre-defined MCP servers (comma-separated list, or \"all\")")
+            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .action(async (servers, opts) => {
+            process.exit(await this.doMcp("deactivate", this.parseTool(opts.tool), servers ?? "all"));
+        });
     }
 }

package/dst/ase-statusline.js

@@ -191,8 +191,8 @@ export default class StatuslineCommand {
             .option("-m, --margin <n>", "reduce maximum used terminal width by <n> characters on each side", parseInteger("--margin"), 2)
             .option("--no-icons", "disable icons in placeholder rendering")
             .option("--no-labels", "disable labels in front of bold values")
-            .argument("[lines...]", "one or more template lines with %u %p %T %s %m %e %t %P %c %C %L %N %a %r " +
-            "%S %D %W %Q %H %X %b %g %G %d %M %V %o placeholders and <color>...</color> markup " +
+            .argument("[lines...]", "one or more template lines with %u %p %T %s %m %e %t %O %P %c %C %a %r " +
+            "%S %D %W %Q %H %X %b %g %G %d %M %V placeholders and <color>...</color> markup " +
             "(color: black, red, green, yellow, blue, magenta, cyan, white, default) " +
             "(default: single line \"%m %e %t\")")
             .action(async (lines, opts) => {

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.49",
+    "version":                              "0.0.51",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -41,6 +41,7 @@
     },
     "dependencies": {
         "commander":                        "14.0.3",
+        "@dotenvx/dotenvx":                 "1.68.1",
         "yaml":                             "2.9.0",
         "valibot":                          "1.4.0",
         "execa":                            "9.6.1",

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

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

package/plugin/agents/ase-meta-chat.md

@@ -1,10 +1,54 @@
 ---
 name: ase-meta-chat
-description: "Query Foreign LLM for Chat"
-model: haiku
+description: "Query Foreign LLM for Chat via MCP Tool"
+effort: high
+tools:
+    - mcp__chat-openai-chatgpt__query
+    - mcp__chat-google-gemini__query
+    - mcp__chat-deepseek__query
+    - mcp__chat-xai-grok__query
+    - mcp__chat-zai-glm__query
+    - mcp__chat-alibaba-qwen__query
 ---
 
-With a corresponding *MCP server* named `ase-chat-xxx`,
-just perform the given *queries*,
-and give back the *plain responses without any modifications*.
+@../meta/ase-control.md
 
+1.  Treat `$ARGUMENTS` as a single whitespace-separated string.
+    Set <llm/> to the *first* token.
+    Set <query/> to the *second and all following* tokens.
+    You *MUST* *NOT* output anything related to this step.
+
+2.  Set <server></server> (set to empty).
+
+    <if condition="<llm/> is equal 'chatgpt'"> <server>chat-openai-chatgpt</server></if>
+    <if condition="<llm/> is equal 'gemini'">  <server>chat-google-gemini</server> </if>
+    <if condition="<llm/> is equal 'deepseek'"><server>chat-deepseek</server>      </if>
+    <if condition="<llm/> is equal 'grok'">    <server>chat-xai-grok</server>      </if>
+    <if condition="<llm/> is equal 'glm'">     <server>chat-zai-glm</server>       </if>
+    <if condition="<llm/> is equal 'qwen'">    <server>chat-alibaba-qwen</server>  </if>
+
+    <if condition="<server/> is empty">
+        You *MUST* output the following <template/> and immediately *STOP* processing
+        (do *NOT* continue with any further step and do *NOT* call any MCP tool):
+
+        <template>
+        ERROR: unknown LLM `<llm/>` (has to be one of: chatgpt, gemini, deepseek, grok, glm, qwen)
+        </template>
+    </if>
+
+3.  Check whether the MCP server <server/> is available (because perhaps
+    it is currently disabled or not configured at all).
+
+    You *MUST* *NOT* output anything related to this step, except if
+    the MCP server <server/> is not available, then just output the
+    following <template/> and immediately *STOP* processing:
+
+    <template>
+    ERROR: LLM `<llm/>` requires MCP server `<server/>`, but it is (currently) not available!
+    </template>
+
+4.  Now call the MCP tool `query(query: <query/>)` from the MCP server
+    <server/> and then return its result `text` *verbatim* and
+    *without any modifications*. Especially, do *NOT* add or remove
+    any text to the MCP server response on your own and do not
+    interpret the result in any way.

package/plugin/agents/ase-meta-diagram.md

@@ -0,0 +1,60 @@
+---
+name: ase-meta-diagram
+description: "Diagram Rendering"
+tools:
+    - "mcp__plugin_ase_ase__diagram"
+effort: high
+---
+
+Your role is to render a *single* diagram, with *deterministic* and
+*clean* output. Your objective is to produce a beautifully rendered
+diagram, derived from the *Mermaid* diagram specification passed in
+`$ARGUMENTS`, which is rendered with the `diagram` tool of the `ase`
+MCP service. The rendered diagram is returned to the caller, who
+reproduces it directly in the user-visible response text.
+
+Rules
+-----
+
+-   INPUT:
+    The `$ARGUMENTS` *MUST* be treated as a *Mermaid* diagram
+    specification!
+
+    The renderer supports the following Mermaid diagram types only:
+
+    -   *structure / layout / components / dependencies* → `flowchart`
+    -   *control flow / branching / concurrency*         → `flowchart`
+    -   *state machine / states / transitions*           → `stateDiagram-v2`
+    -   *data flow / actors / messages / protocols*      → `sequenceDiagram`
+    -   *data structure / classes / methods*             → `classDiagram`
+    -   *data model / entities / relationships*          → `erDiagram`
+    -   *metrics / distributions / time series*          → `xychart-beta`
+
+    Other Mermaid diagram types are *not* supported by the renderer.
+
+-   RENDER:
+    You *MUST* always use the `diagram` tool from the `ase` MCP service
+    to render the diagram!
+
+    Pass the Mermaid diagram specification from `$ARGUMENTS` in the
+    `diagram` field, and pass a `colorMode` of `none` to always get
+    monochrome renderings. You *MUST* *NEVER* hand-draw diagrams under
+    any circumstances! Box-drawing characters (`┌`, `│`, `└`, `┐`,
+    `┘`, `─`, `┼`, `├`, `┤`, `┬`, `┴`, `╭`, `╰`), ASCII surrogates
+    (`+`, `-`, `|`), or any other attempt to draw a framed shape
+    token-by-token are *forbidden* as your own output.
+
+-   OUTPUT:
+    You *MUST* return *exclusively* the `text` output of the `diagram`
+    tool, reproduced *verbatim* into a single Markdown-fenced code block
+    (triple backticks). Do *not* return any other output, especially no
+    prose, no preamble, no summary, and no Mermaid specification.
+
+        ```
+        <text-output-of-diagram-tool/>
+        ```
+
+    The caller copies this returned block directly into the user-visible
+    response text. Returning anything other than the fenced rendered
+    block is a defect: the diagram is then effectively invisible or
+    polluted with extraneous text.