@rse/ase 0.0.50 → 0.0.52

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/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.50",
+    "version":                              "0.0.52",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -18,8 +18,8 @@
     "devDependencies": {
         "eslint":                           "9.39.4",
         "@eslint/js":                       "9.39.4",
-        "@typescript-eslint/parser":        "8.59.4",
-        "@typescript-eslint/eslint-plugin": "8.59.4",
+        "@typescript-eslint/parser":        "8.60.0",
+        "@typescript-eslint/eslint-plugin": "8.60.0",
         "eslint-plugin-promise":            "7.3.0",
         "eslint-plugin-import":             "2.32.0",
         "neostandard":                      "0.13.0",
@@ -41,8 +41,9 @@
     },
     "dependencies": {
         "commander":                        "14.0.3",
+        "@dotenvx/dotenvx":                 "1.69.0",
         "yaml":                             "2.9.0",
-        "valibot":                          "1.4.0",
+        "valibot":                          "1.4.1",
         "execa":                            "9.6.1",
         "mkdirp":                           "3.0.1",
         "@hapi/hapi":                       "21.4.9",

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

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

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

@@ -1,43 +1,54 @@
 ---
 name: ase-meta-chat
 description: "Query Foreign LLM for Chat via MCP Tool"
-effort: low
+effort: high
 tools:
-    - "mcp__chat-openai-chatgpt__chat-with-openai-chatgpt"
-    - "mcp__chat-google-gemini__chat-with-google-gemini"
-    - "mcp__chat-deepseek__chat-with-deepseek"
-    - "mcp__chat-xai-grok__chat-with-xai-grok"
+    - 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
 ---
 
-1.  **Determine LLM and Query**:
+@../meta/ase-control.md
 
-    Set <llm>$ARGUMENTS[0]</llm>.
-    Set <query/> to the second and following tokens in `$ARGUMENTS`.
+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.  **Determine MCP Tool**:
+2.  Set <server></server> (set to empty).
 
-    Use the <llm/> to determine the corresponding MCP tool <tool/>, from
-    the following list of potentially available MCP tool:
+    <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>
 
-    - **OpenAI ChatGPT** (<llm/> `chatgpt`): MCP <tool/> `chat-with-openai-chatgpt`
-    - **Google Gemini** (<llm/> `gemini`):   MCP <tool/> `chat-with-google-gemini`
-    - **DeepSeek** (<llm/> `deepseek`):      MCP <tool/> `chat-with-deepseek`
-    - **xAI Grok** (<llm/> `grok`):          MCP <tool/> `chat-with-xai-grok`
+    <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):
 
-    You *MUST* *NOT* output anything related to this step, except if the
-    MCP tool <tool/> cannot be determined (because the corresponding
-    MCP server is not available or currently disabled), just output the
+        <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/>` required MCP tool `<tool/>`, but this is (currently) not available.
+    ERROR: LLM `<llm/>` requires MCP server `<server/>`, but it is (currently) not available!
     </template>
 
-3.  **Call MCP Tool**:
-
-    Else, call the MCP tool with `<tool/>(content: <query/>)` and
-    then return its result *verbatim* and *without any modifications*.
-    Especially, do *NOT* add or remove any text from the agent response
-    on your own and do not interpret the result in any way.
-
+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

@@ -3,7 +3,7 @@ name: ase-meta-diagram
 description: "Diagram Rendering"
 tools:
     - "mcp__plugin_ase_ase__diagram"
-effort: low
+effort: high
 ---
 
 Your role is to render a *single* diagram, with *deterministic* and

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

@@ -7,6 +7,11 @@ tools:
     - "WebSearch"
 model: sonnet
 effort: low
+tools:
+    - "mcp__search-perplexity__perplexity_search"
+    - "mcp__search-brave__brave_web_search"
+    - "mcp__search-exa__web_search_exa"
+    - "WebSearch"
 ---
 
 Just perform the given *query* `$ARGUMENTS` and

package/plugin/etc/stx.conf

@@ -4,19 +4,19 @@
 ##  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 ##
 
-#   lint project
+#   [plugin] lint project
 lint
     markdownlint-cli2 --config etc/markdownlint.yaml skills/**/*.md
 
-#   build project
+#   [plugin] build project
 build : lint
     true
 
-#   remove all generated files
+#   [plugin] remove all generated files
 clean
     true
 
-#   remove all built files
+#   [plugin] remove all built files
 distclean: clean
     shx rm -f package-lock.json
     shx rm -rf node_modules

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

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

@@ -78,6 +78,8 @@ by querying *multiple* AIs for an *optimal consensus*.
     <expand name="agent" arg1="Google Gemini"  arg2="gemini"></expand>
     <expand name="agent" arg1="DeepSeek"       arg2="deepseek"></expand>
     <expand name="agent" arg1="xAI Grok"       arg2="grok"></expand>
+    <expand name="agent" arg1="Z.AI GLM"       arg2="glm"></expand>
+    <expand name="agent" arg1="Alibaba Qwen"   arg2="qwen"></expand>
 
     You *MUST* *NOT* output anything in this step.
 

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

@@ -8,8 +8,10 @@ user-invocable: true
 disable-model-invocation: false
 effort: low
 allowed-tools:
-    - "mcp__perplexity__perplexity_search"
-    - "mcp__brave__brave_web_search"
+    - "mcp__search-perplexity__perplexity_search"
+    - "mcp__search-brave__brave_web_search"
+    - "mcp__search-exa__web_search_exa"
+    - "WebSearch"
     - "Agent"
 ---
 
@@ -47,18 +49,26 @@ Your objective is to *search* the *Internet*/*Web* for the following query:
     ```
     </define>
 
-    If the MCP tool `mcp__perplexity__perplexity_search` is available, call:
+    If the MCP tool `perplexity_search` from the MCP server `search-perplexity` is available:
     <expand name="agent">
-        Call the MCP tool `mcp__perplexity__perplexity_search(query: "<query/>")`
+        Call the MCP tool `perplexity_search(query: "<query/>")`
+        from the MCP server `search-perplexity`.
     </expand>
 
-    If the MCP tool `mcp__brave__brave_web_search` is available, call:
+    If the MCP tool `brave_web_search` from the MCP server `search-brave` is available:
     <expand name="agent">
-        Call the MCP tool `mcp__brave__brave_web_search(query: "<query/>")`
+        Call the MCP tool `brave_web_search(query: "<query/>")`
+        from the MCP server `search-brave`.
     </expand>
 
+    If the MCP tool `web_search_exa` from the MCP server `search-exa` is available:
     <expand name="agent">
-        Call the tool `WebSearch(query: "<query/>")`
+        Call the MCP tool `web_search_exa(query: "<query/>")`
+        from the MCP server `search-exa`.
+    </expand>
+
+    <expand name="agent">
+        Call the tool `WebSearch(query: "<query/>")`.
     </expand>
 
     </step>

package/dst/ase-claude.js

@@ -1,116 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-import { execa, execaSync } from "execa";
-import which from "which";
-import { Config, configSchema, parseScope } from "./ase-config.js";
-/*  default statusline arguments (claudeX fallback) used when the
-    "agent.statusline" config variable is empty or unset  */
-const DEFAULT_STATUSLINE_ARGS = "-w 0 -m 2 '<blue>%u</blue> <red>%p</red> <black>%T</black> %s' '%m %e %t' '%P %c'";
-/*  CLI command "ase claude"  */
-export default class ClaudeCommand {
-    log;
-    constructor(log) {
-        this.log = log;
-    }
-    /*  ensure a tool is available  */
-    async ensureTool(tool) {
-        return which(tool).catch(() => {
-            throw new Error(`mandatory tool "${tool}" not found in $PATH`);
-        });
-    }
-    /*  resolve the statusline command-line arguments from the layered
-        ASE configuration ("agent.statusline"), falling back to the
-        claudeX default if the value is empty or unavailable  */
-    resolveStatuslineArgs() {
-        let args = "";
-        try {
-            const cfg = new Config("config", configSchema, this.log, parseScope("project"));
-            cfg.read("lenient");
-            args = String(cfg.get("agent.statusline") ?? "").trim();
-        }
-        catch (_e) {
-            /*  cascade unavailable; keep fallback  */
-        }
-        if (args === "")
-            args = DEFAULT_STATUSLINE_ARGS;
-        return args;
-    }
-    /*  register commands  */
-    register(program) {
-        program
-            .command("claude")
-            .description("start Claude Code with bootstrapped ASE environment and settings")
-            .passThroughOptions()
-            .allowUnknownOption()
-            .argument("[args...]", "arguments forwarded verbatim to the \"claude\" CLI")
-            .action(async (args) => {
-            /*  ensure Claude Code CLI is available  */
-            await this.ensureTool("claude");
-            /*  bootstrap ASE_TERM_WIDTH from terminal columns  */
-            if (process.env.ASE_TERM_WIDTH === undefined) {
-                let width = 0;
-                if (process.stdout.isTTY) {
-                    const cols = process.stdout.columns;
-                    if (typeof cols === "number" && cols > 0)
-                        width = cols;
-                }
-                process.env.ASE_TERM_WIDTH = `${width}`;
-            }
-            /*  bootstrap ASE_TERM_HEIGHT from terminal rows  */
-            if (process.env.ASE_TERM_HEIGHT === undefined) {
-                let height = 0;
-                if (process.stdout.isTTY) {
-                    const rows = process.stdout.rows;
-                    if (typeof rows === "number" && rows > 0)
-                        height = rows;
-                }
-                process.env.ASE_TERM_HEIGHT = `${height}`;
-            }
-            /*  bootstrap ASE_TERM_COLORS from "tput colors"  */
-            if (process.env.ASE_TERM_COLORS === undefined) {
-                let colorMode = "none";
-                try {
-                    const { stdout } = execaSync("tput", ["colors"], { reject: false });
-                    const n = parseInt(stdout.trim(), 10);
-                    if (!Number.isNaN(n) && n >= 256)
-                        colorMode = "ansi256";
-                    else if (!Number.isNaN(n) && n >= 16)
-                        colorMode = "ansi16";
-                }
-                catch (_e) {
-                    /*  ignore  */
-                }
-                process.env.ASE_TERM_COLORS = colorMode;
-            }
-            /*  resolve statusline arguments (config or claudeX fallback)  */
-            const statuslineArgs = this.resolveStatuslineArgs();
-            /*  build inline Claude Code settings JSON  */
-            const settings = {
-                env: {
-                    DISABLE_TELEMETRY: "1",
-                    DISABLE_AUTOUPDATER: "1",
-                    DISABLE_BUG_COMMAND: "1",
-                    DISABLE_ERROR_REPORTING: "1"
-                },
-                statusLine: {
-                    type: "command",
-                    command: `ase statusline ${statuslineArgs}`,
-                    padding: 0
-                }
-            };
-            const settingsJSON = JSON.stringify(settings);
-            /*  exec Claude Code with the inline settings prepended
-                and any user-supplied arguments forwarded verbatim  */
-            const result = await execa("claude", ["--settings", settingsJSON, ...args], {
-                stdio: "inherit",
-                env: process.env,
-                reject: false,
-                windowsHide: false
-            });
-            process.exit(result.exitCode ?? 0);
-        });
-    }
-}

package/dst/ase-decision.js

@@ -1,67 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-import { z } from "zod";
-/*  reusable functionality: weighted multi-criteria decision matrix  */
-export class Decision {
-    /*  compute the per-alternative product-sum (rating) row from a
-        weighted decision matrix. Each input row has the shape
-        `[weight, eval_1, eval_2, ..., eval_N]`. For each alternative
-        column j (1..N), the result is the sum over all rows K of
-        `weight_K * eval_K_j`. The output array has length N.  */
-    static productSum(matrix) {
-        if (matrix.length === 0)
-            return [];
-        const cols = matrix[0].length;
-        if (cols < 2)
-            throw new Error("each row must contain a weight followed by at least one evaluation column");
-        const N = cols - 1;
-        const ratings = new Array(N).fill(0);
-        for (let i = 0; i < matrix.length; i++) {
-            const row = matrix[i];
-            if (row.length !== cols)
-                throw new Error(`row ${i} has ${row.length} columns, expected ${cols}`);
-            const weight = row[0];
-            for (let j = 0; j < N; j++)
-                ratings[j] += weight * row[j + 1];
-        }
-        return ratings;
-    }
-}
-/*  MCP registration entry point for the decision-matrix tool  */
-export class DecisionMCP {
-    register(mcp) {
-        mcp.registerTool("decision_matrix", {
-            title: "ASE decision matrix",
-            description: "Compute the per-alternative product-sum (rating) row of a weighted " +
-                "multi-criteria decision matrix. The input `matrix` is an array of rows, " +
-                "one row per criterion, where each row has the shape " +
-                "`[weight, eval_1, eval_2, ..., eval_N]` (i.e. the criterion weight " +
-                "followed by N evaluation values, one per alternative). For each " +
-                "alternative column j (1..N), the result is the sum over all rows K of " +
-                "`weight_K * eval_K_j`. Returns a JSON `text` array of length N with " +
-                "the raw, unrounded ratings (one per alternative, in the same column " +
-                "order as the input).",
-            inputSchema: {
-                matrix: z.array(z.array(z.number()))
-                    .describe("Decision matrix rows: each row is `[weight, eval_1, ..., eval_N]`")
-            }
-        }, async (args) => {
-            try {
-                const result = Decision.productSum(args.matrix);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result) }]
-                };
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return {
-                    isError: true,
-                    content: [{ type: "text", text: `ERROR: ${message}` }]
-                };
-            }
-        });
-    }
-}

package/dst/ase-foo.js

@@ -1,21 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-/*  command-line handling  */
-export default class FooCommand {
-    log;
-    constructor(log) {
-        this.log = log;
-    }
-    /*  register commands  */
-    register(program) {
-        program
-            .command("foo")
-            .description("Print a nice Hello World message")
-            .action(() => {
-            process.stdout.write("Hello, World!\n");
-        });
-    }
-}

package/dst/ase-hello.js

@@ -1,23 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-import chalk from "chalk";
-/*  command-line handling  */
-export default class HelloCommand {
-    log;
-    constructor(log) {
-        this.log = log;
-    }
-    /*  register commands  */
-    register(program) {
-        program
-            .command("hello")
-            .description("Print a nice greeting in red")
-            .option("-s, --subject <subject>", "subject to greet", "Hello")
-            .action((opts) => {
-            process.stdout.write(chalk.red(`${opts.subject} Universe!`) + "\n");
-        });
-    }
-}

package/dst/ase-helloxx.js

@@ -1,23 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-import chalk from "chalk";
-/*  command-line handling  */
-export default class HelloxxCommand {
-    log;
-    constructor(log) {
-        this.log = log;
-    }
-    /*  register commands  */
-    register(program) {
-        program
-            .command("helloxx")
-            .description("Print a Hello World greeting")
-            .action(() => {
-            process.stdout.write(chalk.bold.green("Hello, World!") + "\n");
-            process.exit(0);
-        });
-    }
-}

package/dst/ase-launch.js

@@ -1,109 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-import { execa, execaSync } from "execa";
-import which from "which";
-import { Config, configSchema, parseScope } from "./ase-config.js";
-/*  list of supported tools for "ase launch <tool>"  */
-const SUPPORTED_TOOLS = ["claude"];
-/*  default statusline arguments (used when "agent.statusline" is empty/unset)  */
-const DEFAULT_STATUSLINE_ARGS = "-w 0 -m 2 '<blue>%u</blue> <red>%p</red> <black>%T</black> %s' '%m %e %t' '%P %c'";
-/*  CLI command "ase launch"  */
-export default class LaunchCommand {
-    log;
-    constructor(log) {
-        this.log = log;
-    }
-    /*  resolve the effective "agent.statusline" from the layered
-        configuration cascade (default < user < project)  */
-    readStatuslineConfig() {
-        let statusline = "";
-        try {
-            const cfg = new Config("config", configSchema, this.log, parseScope(undefined));
-            cfg.read("lenient");
-            statusline = String(cfg.get("agent.statusline") ?? "").trim();
-        }
-        catch (_e) {
-            /*  cascade unavailable; leave default  */
-        }
-        /*  reject shell metacharacters to prevent command injection through
-            the configured value when later interpolated into a shell command  */
-        if (statusline !== "" && /[;&|`$\n\r]/.test(statusline))
-            throw new Error("invalid \"agent.statusline\" configuration value: " +
-                "must not contain shell metacharacters (; & | ` $ newline)");
-        return statusline;
-    }
-    /*  populate ASE_TERM_* environment variables (only if unset),
-        so downstream tools (e.g. the diagram renderer) get reliable
-        terminal sizing/color information regardless of the launched tool  */
-    populateTermEnv() {
-        const tty = process.stdout.isTTY;
-        if (process.env.ASE_TERM_WIDTH === undefined) {
-            const cols = tty ? process.stdout.columns : 0;
-            process.env.ASE_TERM_WIDTH = `${typeof cols === "number" && cols > 0 ? cols : 0}`;
-        }
-        if (process.env.ASE_TERM_HEIGHT === undefined) {
-            const rows = tty ? process.stdout.rows : 0;
-            process.env.ASE_TERM_HEIGHT = `${typeof rows === "number" && rows > 0 ? rows : 0}`;
-        }
-        if (process.env.ASE_TERM_COLORS === undefined) {
-            let colorMode = "none";
-            try {
-                const { stdout } = execaSync("tput", ["colors"], { reject: false });
-                const n = parseInt(stdout.trim(), 10);
-                if (!Number.isNaN(n) && n >= 256)
-                    colorMode = "ansi256";
-                else if (!Number.isNaN(n) && n >= 16)
-                    colorMode = "ansi16";
-            }
-            catch (_e) {
-                /*  ignore  */
-            }
-            process.env.ASE_TERM_COLORS = colorMode;
-        }
-    }
-    /*  handler for "ase launch <tool> [<options>...]"  */
-    async run(tool, args) {
-        /*  populate ASE_TERM_* environment variables (always, regardless of tool)  */
-        this.populateTermEnv();
-        /*  dispatch by tool name  */
-        if (tool === "claude") {
-            await which("claude").catch(() => {
-                throw new Error("required tool \"claude\" not found in $PATH");
-            });
-            let statusline = this.readStatuslineConfig();
-            if (statusline === "")
-                statusline = DEFAULT_STATUSLINE_ARGS;
-            const settingsJson = JSON.stringify({
-                statusLine: {
-                    type: "command",
-                    command: `ase statusline ${statusline}`,
-                    padding: 0
-                }
-            });
-            const result = await execa("claude", ["--settings", settingsJson, ...args], {
-                stdio: "inherit",
-                env: process.env,
-                reject: false
-            });
-            return result.exitCode ?? 0;
-        }
-        else
-            throw new Error(`unsupported tool "${tool}" ` +
-                `(expected one of: ${SUPPORTED_TOOLS.join(", ")})`);
-    }
-    /*  register commands  */
-    register(program) {
-        program
-            .command("launch <tool> [options...]")
-            .description("launch a supported tool with bootstrapped environment and settings " +
-            `(supported tools: ${SUPPORTED_TOOLS.join(", ")})`)
-            .passThroughOptions()
-            .allowUnknownOption()
-            .action(async (tool, options) => {
-            process.exit(await this.run(tool, options));
-        });
-    }
-}

package/dst/ase-plan.js

@@ -1,143 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-import path from "node:path";
-import os from "node:os";
-import fs from "node:fs";
-/*  validate the plan id to keep it safe as a filename component  */
-const validateId = (id) => {
-    if (typeof id !== "string" || id.length === 0)
-        throw new Error("plan: id must be a non-empty string");
-    if (!/^[A-Za-z0-9-]+$/.test(id))
-        throw new Error("plan: id must match [A-Za-z0-9-]+");
-};
-/*  resolve the on-disk path for a given plan id  */
-const planPath = (id) => {
-    validateId(id);
-    return path.join(os.homedir(), ".ase", "plan", `${id}.md`);
-};
-/*  load a plan; returns empty string if no plan exists  */
-export const planLoad = (id) => {
-    const file = planPath(id);
-    if (!fs.existsSync(file))
-        return "";
-    return fs.readFileSync(file, "utf8");
-};
-/*  save a plan as UTF-8 text under the given id  */
-export const planSave = (id, text) => {
-    if (typeof text !== "string")
-        throw new Error("plan: text must be a string");
-    const file = planPath(id);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, text, "utf8");
-};
-/*  delete a plan by id; returns true if a plan existed and was removed  */
-export const planDelete = (id) => {
-    const file = planPath(id);
-    if (!fs.existsSync(file))
-        return false;
-    fs.rmSync(file);
-    return true;
-};
-/*  purge plans whose modification time is older than the given cutoff in
-    milliseconds; returns the list of removed plan ids  */
-export const planPurge = (maxAgeMs) => {
-    const dir = path.join(os.homedir(), ".ase", "plan");
-    if (!fs.existsSync(dir))
-        return [];
-    const cutoff = Date.now() - maxAgeMs;
-    const removed = [];
-    for (const entry of fs.readdirSync(dir)) {
-        if (!entry.endsWith(".md"))
-            continue;
-        const file = path.join(dir, entry);
-        const st = fs.statSync(file);
-        if (!st.isFile())
-            continue;
-        if (st.mtimeMs < cutoff) {
-            fs.rmSync(file);
-            removed.push(entry.slice(0, -3));
-        }
-    }
-    return removed;
-};
-/*  read all of stdin as a UTF-8 string  */
-const readStdin = () => {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        process.stdin.on("data", (chunk) => chunks.push(chunk));
-        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-        process.stdin.on("error", (err) => reject(err));
-    });
-};
-/*  CLI command "ase plan"  */
-export default class PlanCommand {
-    log;
-    constructor(log) {
-        this.log = log;
-    }
-    /*  register commands  */
-    register(program) {
-        /*  register CLI top-level command "ase plan"  */
-        const plan = program
-            .command("plan")
-            .description("Manage persisted plans under ~/.ase/plan/<id>.md")
-            .action(() => {
-            plan.outputHelp();
-            process.exit(1);
-        });
-        /*  register CLI sub-command "ase plan load"  */
-        plan
-            .command("load")
-            .description("Load a plan by id and write it to stdout")
-            .argument("<id>", "Plan identifier")
-            .action((id) => {
-            const text = planLoad(id);
-            process.stdout.write(text);
-            process.exit(0);
-        });
-        /*  register CLI sub-command "ase plan save"  */
-        plan
-            .command("save")
-            .description("Save a plan by id, reading content from stdin")
-            .argument("<id>", "Plan identifier")
-            .action(async (id) => {
-            const text = await readStdin();
-            planSave(id, text);
-            this.log.write("info", `plan: saved "${id}"`);
-            process.exit(0);
-        });
-        /*  register CLI sub-command "ase plan delete"  */
-        plan
-            .command("delete")
-            .description("Delete a plan by id")
-            .argument("<id>", "Plan identifier")
-            .action((id) => {
-            const removed = planDelete(id);
-            if (removed)
-                this.log.write("info", `plan: removed "${id}"`);
-            else
-                this.log.write("info", `plan: no plan "${id}" to remove`);
-            process.exit(removed ? 0 : 1);
-        });
-        /*  register CLI sub-command "ase plan purge"  */
-        plan
-            .command("purge")
-            .description("Remove all plans with a modification time older than <days> (default: 31)")
-            .argument("[<days>]", "Maximum plan age in days", "31")
-            .action((days) => {
-            const n = Number.parseInt(days, 10);
-            if (!Number.isFinite(n) || n < 0)
-                throw new Error("plan: <days> must be a non-negative integer");
-            const removed = planPurge(n * 24 * 60 * 60 * 1000);
-            if (removed.length === 0)
-                this.log.write("info", "plan: no plans to purge");
-            else
-                for (const id of removed)
-                    this.log.write("info", `plan: purged "${id}"`);
-            process.exit(0);
-        });
-    }
-}

package/dst/ase-service-probe.js

@@ -1,38 +0,0 @@
-/*
-**  Agentic Software Engineering (ASE)
-**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-import axios from "axios";
-import * as v from "valibot";
-/*  shared service host  */
-export const SERVICE_HOST = "127.0.0.1";
-/*  schema for ".ase/service.yaml"  */
-export const serviceSchema = v.nullish(v.strictObject({
-    port: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1024), v.maxValue(65535)))
-}));
-/*  distinguish ECONNREFUSED from other Axios transport errors  */
-export const isConnRefused = (err) => {
-    const e = err;
-    return e?.code === "ECONNREFUSED" || e?.cause?.code === "ECONNREFUSED";
-};
-/*  probe the service and verify ASE identity banner  */
-export const probe = async (port, projectId) => {
-    try {
-        const r = await axios.request({
-            method: "OPTIONS",
-            url: `http://${SERVICE_HOST}:${port}/`,
-            timeout: 2000,
-            validateStatus: () => true
-        });
-        if (r.status < 200 || r.status >= 300)
-            return false;
-        const d = r.data;
-        return d?.ase === true && d?.projectId === projectId;
-    }
-    catch (err) {
-        if (isConnRefused(err))
-            return null;
-        throw err;
-    }
-};