@rse/ase 0.9.54 → 0.9.56

package/dst/ase-log.js

@@ -12,6 +12,8 @@ const levels = [
     { name: "info", style: chalk.blue },
     { name: "debug", style: chalk.green }
 ];
+/*  check whether an arbitrary string is a valid log level  */
+export const isLogLevel = (level) => levels.some((l) => l.name === level);
 export default class Log {
     _program;
     _logLevel;
@@ -36,11 +38,14 @@ export default class Log {
         return stream;
     }
     logLevel(level) {
+        if (level === undefined)
+            return this._logLevel;
         const idx = levels.findIndex((l) => l.name === level);
         if (idx === -1)
             throw new RangeError(`invalid log level "${level}" (expected one of: ${levels.map((l) => l.name).join(", ")})`);
         this._logLevel = level;
         this.logLevelIdx = idx;
+        return this._logLevel;
     }
     logFile(file) {
         if (file === this._logFile)

package/dst/ase-service.js

@@ -16,6 +16,7 @@ import * as v from "valibot";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { Config, configSchema, ConfigMCP } from "./ase-config.js";
+import { isLogLevel } from "./ase-log.js";
 import { CompatMCP } from "./ase-compat.js";
 import { DiagramMCP } from "./ase-diagram.js";
 import { TaskMCP } from "./ase-task.js";
@@ -61,11 +62,18 @@ export const probe = async (port, projectId) => {
 };
 const SERVE_ENV = "ASE_SERVICE_SERVE";
 const PORT_ENV = "ASE_SERVICE_PORT";
+const LEVEL_ENV = "ASE_SERVICE_LOG_LEVEL";
 const IDLE_MS = 30 * 60 * 1000;
 const TICK_MS = 60 * 1000;
 const PORT_MIN = 42000;
 const PORT_MAX = 44000;
 const PORT_TRIES = 20;
+/*  bounds for the append-only ".ase/service.log" file:
+    maximum tolerated size, number of tail lines surviving a trim,
+    and maximum length of the MCP tool call arguments logged per request  */
+const LOG_MAX_SIZE = 1024 * 1024;
+const LOG_KEEP_LINES = 2000;
+const LOG_ARGS_MAX = 200;
 /*  load the optional "config.yaml" and "service.yaml" files and derive
     the service identity context (project id, port, service config)  */
 export const loadServiceContext = (log) => {
@@ -130,15 +138,32 @@ export class Service {
                 svc.write();
         });
     }
+    /*  trim the log file down to its tail if it grew beyond the size limit  */
+    static trimLog(logFile) {
+        try {
+            if (!fs.existsSync(logFile) || fs.statSync(logFile).size <= LOG_MAX_SIZE)
+                return;
+            const tail = Service.readLogTail(logFile, LOG_KEEP_LINES);
+            fs.writeFileSync(logFile, tail.length > 0 ? `${tail}\n` : "");
+        }
+        catch {
+            /*  intentionally ignore all trimming errors, as a
+                non-trimmable log file must never block the service  */
+        }
+    }
     /*  spawn the current executable detached as a background service  */
-    static spawnDetached(aseDir, port) {
+    static spawnDetached(aseDir, port, logLevel) {
         fs.mkdirSync(aseDir, { recursive: true });
         const logFile = path.join(aseDir, "service.log");
+        /*  trim the log before handing it to the service, as the detached
+            service inherits the file descriptor for its entire lifetime and
+            hence cannot rotate the file itself while it is running  */
+        Service.trimLog(logFile);
         const fd = fs.openSync(logFile, "a");
         const entry = fileURLToPath(new URL("./ase.js", import.meta.url));
         const child = spawn(process.execPath, [entry, "service", "start"], {
             detached: true,
-            env: { ...process.env, [SERVE_ENV]: "1", [PORT_ENV]: String(port) },
+            env: { ...process.env, [SERVE_ENV]: "1", [PORT_ENV]: String(port), [LEVEL_ENV]: logLevel },
             stdio: ["ignore", fd, fd]
         });
         fs.closeSync(fd);
@@ -285,11 +310,20 @@ export default class ServiceCommand {
                 bodyInfo = ` [${bMethod}]`;
                 if (bName !== null) {
                     bodyInfo += ` ${bName}`;
-                    if (bArgs !== null)
-                        bodyInfo += ` ${JSON.stringify(bArgs)}`;
+                    if (bArgs !== null) {
+                        /*  cap the arguments, as payload-carrying tool calls
+                            (task plans, key/value batches, etc) would
+                            otherwise dominate the entire log file  */
+                        const args = JSON.stringify(bArgs);
+                        bodyInfo += ` ${args.length > LOG_ARGS_MAX ? `${args.slice(0, LOG_ARGS_MAX)}…` : args}`;
+                    }
                 }
             }
-            this.log.write("info", `mcp: ${request.method.toUpperCase()} ${request.path}${bodyInfo}`);
+            /*  log tool calls regularly, but all remaining MCP traffic
+                (session handshakes, notifications, SSE stream opens) at
+                debug level only, as it carries no diagnostic value  */
+            const level = bMethod === "tools/call" ? "info" : "debug";
+            this.log.write(level, `mcp: ${request.method.toUpperCase()} ${request.path}${bodyInfo}`);
             const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
             const mcp = buildMcpServer();
             request.raw.res.on("close", () => {
@@ -394,6 +428,11 @@ export default class ServiceCommand {
         const ctx = this.loadContext();
         let port = ctx.port;
         if (process.env[SERVE_ENV] === "1") {
+            /*  adopt the log level of the spawning process, as the
+                detached service is started without any CLI options  */
+            const level = process.env[LEVEL_ENV];
+            if (level !== undefined && isLogLevel(level))
+                this.log.logLevel(level);
             const raw = process.env[PORT_ENV];
             port = raw !== undefined ? Number(raw) : await Service.allocatePort();
             await this.runService({ ...ctx, port });
@@ -411,7 +450,7 @@ export default class ServiceCommand {
         let lastErr = new Error("service failed to start within timeout");
         for (let attempt = 0; attempt < 3; attempt++) {
             port = await Service.allocatePort();
-            const { child, logFile } = Service.spawnDetached(ctx.aseDir, port);
+            const { child, logFile } = Service.spawnDetached(ctx.aseDir, port, this.log.logLevel());
             let exited = false;
             let exitCode = null;
             let resolveExit = () => { };

package/dst/ase-setup.js

@@ -808,9 +808,11 @@ export default class SetupCommand {
         /*  default for --dev derived from ASE_SETUP_DEV environment variable  */
         const envDev = process.env.ASE_SETUP_DEV ?? "";
         const devDflt = envDev !== "" && envDev !== "0" && envDev.toLowerCase() !== "false";
-        /*  default for --tool derived from ASE_TOOL environment variable  */
+        /*  default for --tool derived from ASE_TOOL environment variable
+            (validated lazily by "parseTool" in each action, so an invalid
+            value cannot break unrelated "ase" commands at startup)  */
         const envTool = process.env.ASE_TOOL ?? "";
-        const toolDflt = envTool !== "" ? this.parseTool(envTool) : "claude";
+        const toolDflt = envTool !== "" ? envTool : "claude";
         /*  register CLI top-level command "ase setup"  */
         const setupCmd = program
             .command("setup")

package/dst/ase-statusline.js

@@ -388,25 +388,23 @@ export default class StatuslineCommand {
                 /*  ==== RATE LIMITS ====  */
                 S: () => {
                     const pct5h = data.rate_limits?.five_hour?.used_percentage;
-                    if (pct5h !== undefined)
-                        emit(`${prefix("⏲", "session-usage")}${c.bold(`${pct5h.toFixed(1)}%`)}`);
+                    const s = pct5h !== undefined ? `${pct5h.toFixed(1)}%` : "-";
+                    emit(`${prefix("⏲", "5h-usage")}${c.bold(s)}`);
                 },
                 D: () => {
                     const until5h = data.rate_limits?.five_hour?.resets_at;
                     const s = formatTimeUntil(until5h);
-                    if (s !== "")
-                        emit(`${prefix("⏱", "session-resets")}${c.bold(s)}`);
+                    emit(`${prefix("⏱", "5h-resets")}${c.bold(s !== "" ? s : "-")}`);
                 },
                 W: () => {
                     const pctWk = data.rate_limits?.seven_day?.used_percentage;
-                    if (pctWk !== undefined)
-                        emit(`${prefix("⏲", "weekly-usage")}${c.bold(`${pctWk.toFixed(1)}%`)}`);
+                    const s = pctWk !== undefined ? `${pctWk.toFixed(1)}%` : "-";
+                    emit(`${prefix("⏲", "7d-usage")}${c.bold(s)}`);
                 },
                 Q: () => {
                     const untilWk = data.rate_limits?.seven_day?.resets_at;
                     const s = formatTimeUntil(untilWk);
-                    if (s !== "")
-                        emit(`${prefix("⏱", "weekly-resets")}${c.bold(s)}`);
+                    emit(`${prefix("⏱", "7d-resets")}${c.bold(s !== "" ? s : "-")}`);
                 },
                 /*  ==== COSTS ====  */
                 H: () => {

package/dst/ase-task.js

@@ -14,6 +14,12 @@ import { LRUCache } from "lru-cache";
 import { Config, configSchema, parseScope } from "./ase-config.js";
 import { Markdown } from "./ase-markdown.js";
 import { readStdin, writeStdout } from "./ase-stdio.js";
+/*  the lifecycle states a task plan can be in, i.e., the accepted
+    values of the "Status:" frontmatter key of a task plan  */
+export const taskStates = [
+    "DRAFTED", "REJECTED", "APPROVED", "DEFERRED",
+    "STARTED", "BLOCKED", "COMPLETED", "CANCELLED"
+];
 /*  reusable functionality: persisted task plans under
     <project>/<basedir>/TASK-<id>.md (driven by the
     "project.artifact.task.{basedir,files}" configuration)  */
@@ -141,12 +147,54 @@ export class Task {
         migrated.sort((a, b) => a.localeCompare(b));
         return migrated;
     }
-    /*  load a task; returns empty string if no task exists  */
+    /*  the legacy task plan header lines, each mapped onto the
+        frontmatter key which superseded it  */
+    static legacy = [
+        { key: "Created", re: /^⎈[ \t]+Created:[ \t]*(.*)$/m },
+        { key: "Modified", re: /^⚙[ \t]+Modified:[ \t]*(.*)$/m },
+        { key: "Kind", re: /^☯[ \t]+Kind:[ \t]*(.*)$/m }
+    ];
+    /*  render a single frontmatter line with a column-aligned key  */
+    static frontLine(key, value) {
+        return (key + ":").padEnd(12) + value;
+    }
+    /*  normalize a legacy task plan -- one carrying its metadata in the
+        "#   TASK <id>: <title>" heading and the "⎈"/"⚙"/"☯" glyph header
+        lines -- into the current Markdown frontmatter shape, so every
+        consumer sees a single plan shape only; a plan already carrying a
+        frontmatter block, and any content without a task heading at all,
+        is passed through verbatim -- in particular, absent optional keys
+        are never materialized, as they read as their default value  */
+    static normalize(id, text) {
+        if (text === "" || /^---\r?\n/.test(text))
+            return text;
+        const heading = /^#[ \t]+TASK(?:[ \t]+[A-Za-z0-9_-]+)?[ \t]*:[ \t]*(.*)$/m.exec(text);
+        if (heading === null)
+            return text;
+        /*  lift the glyph header lines into their frontmatter keys, with
+            the task id taken from the authoritative filename-derived id  */
+        let body = text.replace(heading[0], "");
+        const front = [Task.frontLine("Id", id)];
+        for (const legacy of Task.legacy) {
+            const m = legacy.re.exec(body);
+            if (m === null)
+                continue;
+            front.push(Task.frontLine(legacy.key, m[1].trim()));
+            body = body.replace(m[0], "");
+        }
+        /*  re-assemble the plan from the frontmatter block, the reduced
+            heading, and the body stripped of its now leading blank lines  */
+        return `---\n${front.join("\n")}\n---\n\n` +
+            `#   TASK: ${heading[1].trim()}\n\n` +
+            body.replace(/^(?:[ \t]*\r?\n)+/, "");
+    }
+    /*  load a task, normalized into the current Markdown frontmatter
+        shape; returns empty string if no task exists  */
     static load(log, id) {
         const file = Task.path(log, id);
         if (!fs.existsSync(file))
             return "";
-        return fs.readFileSync(file, "utf8");
+        return Task.normalize(id, fs.readFileSync(file, "utf8"));
     }
     /*  save a task as UTF-8 text under the given id into the
         <project>/<basedir>/TASK-<id>.md file  */
@@ -167,10 +215,11 @@ export class Task {
         return true;
     }
     /*  rename a task by moving its <project>/<basedir>/TASK-<oldId>.md file
-        to <project>/<basedir>/TASK-<newId>.md; the embedded
-        "#   TASK <id>:" heading inside the plan content is rewritten to
-        the new id; returns true on success, false if the source task does
-        not exist; throws if the target id already exists  */
+        to <project>/<basedir>/TASK-<newId>.md; the embedded "Id:"
+        frontmatter key inside the plan content is rewritten to the new id
+        (falling back to the "#   TASK <id>:" heading of a still legacy,
+        not yet normalized plan); returns true on success, false if the
+        source task does not exist; throws if the target id already exists  */
     static rename(log, oldId, newId) {
         const oldFile = Task.path(log, oldId);
         const newFile = Task.path(log, newId);
@@ -179,7 +228,9 @@ export class Task {
         if (fs.existsSync(newFile))
             throw new Error(`task: target id "${newId}" already exists`);
         const text = fs.readFileSync(oldFile, "utf8");
-        const updated = text.replace(/(^#\s+TASK\s+)[A-Za-z0-9_-]+(\s*:)/m, `$1${newId}$2`);
+        const updated = /^---\r?\n/.test(text) ?
+            text.replace(/^(Id:[ \t]*)[A-Za-z0-9_-]+[ \t]*$/m, `$1${newId}`) :
+            text.replace(/(^#\s+TASK\s+)[A-Za-z0-9_-]+(\s*:)/m, `$1${newId}$2`);
         fs.mkdirSync(path.dirname(newFile), { recursive: true });
         fs.writeFileSync(newFile, updated, "utf8");
         fs.rmSync(oldFile, { force: true });
@@ -207,17 +258,55 @@ export class Task {
         }
         return out;
     }
-    /*  list all persisted tasks in lexicographic id order; if verbose is true,
-        each entry's `mtime` is set to the task file's modification time
-        formatted as "YYYY-MM-DD HH:MM", otherwise it is left undefined  */
+    /*  read the "Status:" frontmatter key of a task plan file, falling back
+        to the "DRAFTED" default of the task plan format for a plan whose
+        frontmatter is absent or carries no such key  */
+    static status(file) {
+        const fm = /^---\r?\n([\s\S]*?\r?\n)---\r?\n/.exec(fs.readFileSync(file, "utf8"));
+        if (fm === null)
+            return "DRAFTED";
+        const m = /^Status:[ \t]*(\S+)[ \t]*$/m.exec(fm[1]);
+        if (m === null)
+            return "DRAFTED";
+        return m[1];
+    }
+    /*  list all persisted tasks in lexicographic id order, each with the
+        `status` of its plan; if verbose is true, each entry's `mtime` is
+        set to the task file's modification time formatted as
+        "YYYY-MM-DD HH:MM", otherwise it is left undefined  */
     static list(log, verbose = false) {
         const out = Task.scan(log).map((entry) => ({
             id: entry.id,
+            status: Task.status(entry.file),
             mtime: verbose ? DateTime.fromJSDate(entry.st.mtime).toFormat("yyyy-LL-dd HH:mm") : undefined
         }));
         out.sort((a, b) => a.id.localeCompare(b.id));
         return out;
     }
+    /*  resolve an "include" and an "exclude" comma-separated lifecycle
+        state list into the effective state set a task plan has to be in
+        to be listed at all; the "none" sentinel and empty tokens are
+        silently dropped, an empty "include" list means all states, and
+        the "exclude" list is applied after the "include" list  */
+    static states(include, exclude) {
+        const parse = (list) => list.split(",")
+            .map((token) => token.trim())
+            .filter((token) => token !== "" && token.toUpperCase() !== "NONE")
+            .map((token) => {
+            const state = token.toUpperCase();
+            if (!taskStates.includes(state))
+                throw new Error(`task: invalid state "${token}" ` +
+                    `(expected one of: ${taskStates.join(", ")})`);
+            return state;
+        });
+        const included = parse(include);
+        const excluded = parse(exclude);
+        const states = (included.length > 0 ? included : taskStates)
+            .filter((state) => !excluded.includes(state));
+        if (states.length === 0)
+            throw new Error("task: options \"--include\" and \"--exclude\" cancel out to an empty state set");
+        return states;
+    }
     /*  purge tasks whose modification time is older than the given cutoff in
         milliseconds; returns the list of removed task ids  */
     static purge(log, maxAgeMs) {
@@ -274,12 +363,19 @@ export default class TaskCommand {
         task
             .command("list")
             .description("List all persisted task ids, one per line")
-            .option("-v, --verbose", "also show the task file modification time as (YYYY-MM-DD HH:MM)")
+            .option("-v, --verbose", "also show the task plan status and the task file " +
+            "modification time as (YYYY-MM-DD HH:MM)")
+            .option("-i, --include <states>", "comma-separated list of lifecycle states to list " +
+            `(${taskStates.join("|")}), or "none" for no restriction`, "none")
+            .option("-e, --exclude <states>", "comma-separated list of lifecycle states to not list " +
+            `(${taskStates.join("|")}), or "none" for no exclusion`, "COMPLETED,CANCELLED")
             .action(async (opts) => {
-            const items = Task.list(this.log, opts.verbose ?? false);
+            const states = Task.states(opts.include, opts.exclude);
+            const items = Task.list(this.log, opts.verbose ?? false)
+                .filter((item) => states.includes(item.status));
             for (const item of items) {
                 if (opts.verbose)
-                    await writeStdout(`${item.id}\t(${item.mtime})\n`);
+                    await writeStdout(`${item.id}\t${item.status}\t(${item.mtime})\n`);
                 else
                     await writeStdout(`${item.id}\n`);
             }
@@ -395,7 +491,8 @@ export class TaskMCP {
             title: "ASE task list",
             description: "List all persisted tasks. " +
                 "Returns a `tasks` array (in lexicographic `id` order) where each item has the " +
-                "task `id`. If `verbose` is `true`, each item additionally has an `mtime` field " +
+                "task `id` and the `status` of its plan (the `Status:` frontmatter key, defaulting " +
+                "to `DRAFTED`). If `verbose` is `true`, each item additionally has an `mtime` field " +
                 "(last modification time of the task's `TASK-<id>.md` file, formatted as `YYYY-MM-DD HH:MM`). " +
                 "Returns an empty array if no tasks exist.",
             inputSchema: {
@@ -405,6 +502,7 @@ export class TaskMCP {
             outputSchema: {
                 tasks: z.array(z.object({
                     id: z.string().describe("task identifier"),
+                    status: z.string().describe("task plan lifecycle status (`Status:` frontmatter key, default `DRAFTED`)"),
                     mtime: z.string().optional()
                         .describe("`TASK-<id>.md` modification time (`YYYY-MM-DD HH:MM`); only present if `verbose` is true")
                 })).describe("all persisted tasks in lexicographic id order")
@@ -414,8 +512,8 @@ export class TaskMCP {
                 const verbose = args.verbose ?? false;
                 const items = Task.list(this.log, verbose);
                 const tasks = verbose ?
-                    items.map((item) => ({ id: item.id, mtime: item.mtime ?? "" })) :
-                    items.map((item) => ({ id: item.id }));
+                    items.map((item) => ({ id: item.id, status: item.status, mtime: item.mtime ?? "" })) :
+                    items.map((item) => ({ id: item.id, status: item.status }));
                 const result = { tasks };
                 return {
                     structuredContent: result,
@@ -430,15 +528,34 @@ export class TaskMCP {
         mcp.registerTool("ase_task_load", {
             title: "ASE task load",
             description: "Load a previously persisted task by `id`. " +
-                "Returns the task as `text`; returns an empty string if no task exists for the `id`.",
+                "Returns the task as `text`, normalized into the current Markdown frontmatter shape; " +
+                "returns an empty string if no task exists for the `id`. " +
+                "The `variant` argument selects the returned form of the plan: " +
+                "`source` (the default) is the *authoring* form and the *only* form which may be " +
+                "edited and passed back into `ase_task_save`; " +
+                "`render` is the *rendering-prepared* form, which is for *display only* and " +
+                "MUST NOT be persisted; " +
+                "`both` returns the source form enclosed in `<task-plan-source>` delimiter lines, " +
+                "followed by the render form enclosed in `<task-plan-render>` delimiter lines.",
             inputSchema: {
                 id: z.string()
-                    .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')")
+                    .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')"),
+                variant: z.enum(["source", "render", "both"]).optional()
+                    .describe("returned form of the plan: `source` (authoring form, the default), " +
+                    "`render` (rendering-prepared form, display only), or `both` " +
+                    "(both forms, each enclosed in its delimiter lines)")
             }
         }, async (args) => {
             try {
-                const raw = Task.load(this.log, args.id);
-                const text = Markdown.prepare(raw);
+                const source = Task.load(this.log, args.id);
+                const variant = args.variant ?? "source";
+                let text = source;
+                if (source !== "" && variant === "render")
+                    text = Markdown.prepare(source);
+                else if (source !== "" && variant === "both")
+                    text =
+                        `<task-plan-source>\n${source}\n</task-plan-source>\n\n` +
+                            `<task-plan-render>\n${Markdown.prepare(source)}\n</task-plan-render>\n`;
                 return {
                     content: [{ type: "text", text }]
                 };
@@ -451,21 +568,28 @@ export class TaskMCP {
         mcp.registerTool("ase_task_save", {
             title: "ASE task save",
             description: "Persist a task as `text` under `id`. " +
-                "Overwrites any existing task for the same `id`. " +
-                "Returns the persisted task as `text`, prepared for improved rendering.",
+                "The `text` MUST be the *authoring* form of the plan (as returned by the " +
+                "`source` variant of `ase_task_load`) and hence MUST NOT carry any rendering " +
+                "artifacts. Overwrites any existing task for the same `id`. " +
+                "Returns a status `text` by default, or, if `render` is `true`, the " +
+                "*rendering-prepared* form of the just-saved plan, for display purposes only.",
             inputSchema: {
                 id: z.string()
                     .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')"),
                 text: z.string()
-                    .describe("text content of the task")
+                    .describe("text content of the task, in its authoring form"),
+                render: z.boolean().optional()
+                    .describe("if true, return the rendering-prepared form of the just-saved " +
+                    "plan instead of a status message (default: false)")
             }
         }, async (args) => {
             try {
                 Task.save(this.log, args.id, args.text);
-                /*  return the prepared content, so a caller reusing the
-                    just-saved plan instead of re-loading it still receives
-                    the rendering-prepared variant  */
-                const text = Markdown.prepare(args.text);
+                /*  return the rendering-prepared content on demand, so a caller
+                    displaying the just-saved plan does not have to re-load it  */
+                const text = (args.render ?? false) ?
+                    Markdown.prepare(args.text) :
+                    `OK: saved task "${args.id}"`;
                 return {
                     content: [{ type: "text", text }]
                 };
@@ -501,7 +625,7 @@ export class TaskMCP {
         mcp.registerTool("ase_task_rename", {
             title: "ASE task rename",
             description: "Rename a previously persisted task from `old` to `new` by moving the " +
-                "task `TASK-<id>.md` file and rewriting its embedded task heading. " +
+                "task `TASK-<id>.md` file and rewriting its embedded `Id:` frontmatter key. " +
                 "Returns a status `text` indicating whether the rename succeeded. " +
                 "Fails with an error if the target id already exists.",
             inputSchema: {

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.54",
+    "version":                              "0.9.56",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -18,12 +18,12 @@
     "devDependencies": {
         "eslint":                           "9.39.4",
         "@eslint/js":                       "9.39.4",
-        "@typescript-eslint/parser":        "8.65.0",
-        "@typescript-eslint/eslint-plugin": "8.65.0",
+        "@typescript-eslint/parser":        "8.66.0",
+        "@typescript-eslint/eslint-plugin": "8.66.0",
         "eslint-plugin-promise":            "7.3.0",
         "eslint-plugin-import":             "2.32.0",
         "neostandard":                      "0.13.0",
-        "globals":                          "17.8.0",
+        "globals":                          "17.9.0",
         "typescript":                       "6.0.3",
 
         "@rse/stx":                         "1.1.6",
@@ -42,7 +42,7 @@
     },
     "dependencies": {
         "commander":                        "15.0.0",
-        "@dotenvx/dotenvx":                 "2.19.1",
+        "@dotenvx/dotenvx":                 "2.19.2",
         "yaml":                             "2.9.0",
         "valibot":                          "1.4.2",
         "execa":                            "10.0.1",

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

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.54",
+    "version":     "0.9.56",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.54",
+    "version":     "0.9.56",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.github/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.54",
+    "version":     "0.9.56",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/agents/ase-code-analyze.md

@@ -63,7 +63,7 @@ Workflow
         -   incorrect short-circuit evaluation or operator precedence
         -   logical vs. bitwise operator confusion
         -   negation mistakes in compound predicates
-        -   wrong comparison operator (`==` instead of `===`, `<` vs. `<=`, etc)
+        -   wrong comparison operator (`==` instead of `===`, `<` vs. `<=`, etc.)
         -   inverted condition or swapped if/else branches
         -   dead or duplicated conditional branches
         -   fall-through where a break or return was intended

package/plugin/agents/ase-code-lint.md

@@ -65,10 +65,10 @@ Workflow
         identifiers, string literals and comments.
 
         Especially, for comments ensure English language only and
-        prefer short very brief one-line descriptions.
+        prefer short, very brief one-line descriptions.
 
     -   **A05 - COMPLEXITY**:
-        Check for extremely long functions, and deeply nested code
+        Check for extremely long functions and deeply nested code
         constructs.
 
         Especially, for functions prefer fewer than 100 lines, and for
@@ -185,8 +185,8 @@ Workflow
     -   **A15 - PERFORMANCE**:
         Check for bad performance and inefficiency issues.
 
-        Especially, check for code constructs with a high (i.e., not
-        constant/O(1), or linear/O(n) complexity) in its execution time
+        Especially, check for code constructs with a high complexity (i.e., not
+        constant/O(1), or linear/O(n)) in their execution time
         and/or memory consumption.
 
     -   **A16 - SECURITY**:

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

@@ -56,5 +56,5 @@ tools:
 4.  Now call the MCP tool `query(prompt: <query/>)` from the MCP server
     <server/> and then return its result `text` *verbatim* and *without
     any modifications* as the last message. Especially, do *NOT* add or
-    remove any text to the MCP server response on your own and do not
+    remove any text to or from the MCP server response on your own and do not
     interpret the result in any way.

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

@@ -102,7 +102,7 @@ store those facts in the placeholder named `<arg2/>`.
         <child-4/>.
 
         <expand name="gather-facts"
-            arg1="the CHILDREN topics (narrower topics that are specializations) of the following topic: <topic/>"
+            arg1="the CHILD topics (narrower topics that are specializations) of the following topic: <topic/>"
             arg2="facts-children"></expand>
 
         Ground the determination of the canonical names of the most