@rse/ase 0.9.58 → 0.9.60

package/dst/ase-hook.js

@@ -75,6 +75,10 @@ const toolInputSchema = v.object({
     skill: v.optional(v.string()),
     file_path: v.optional(v.string())
 });
+/*  maximum tolerated age of an idle session directory: the session-end hook
+    removes it regularly, but a crashed or SIGKILLed agent leaves it behind
+    forever, so orphans are garbage-collected once they exceed this age  */
+const SESSION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 /*  CLI command "ase hook"  */
 export default class HookCommand {
     log;
@@ -85,6 +89,40 @@ export default class HookCommand {
     isValidSessionId(id) {
         return /^[A-Za-z0-9._-]+$/.test(id);
     }
+    /*  resolve the base directory holding all per-session state  */
+    sessionBaseDir() {
+        return path.join(os.homedir(), ".ase", "session");
+    }
+    /*  garbage-collect orphaned session directories left behind by agents
+        which died before their session-end hook could run; a live session
+        keeps its directory's mtime current, as every tool call acquires a
+        lock file inside it, so plain age is a reliable liveness signal  */
+    pruneStaleSessions(currentSessionId) {
+        const base = this.sessionBaseDir();
+        let entries;
+        try {
+            entries = fs.readdirSync(base, { withFileTypes: true });
+        }
+        catch (_e) {
+            /*  best-effort: no base directory yet, or unreadable  */
+            return;
+        }
+        const deadline = Date.now() - SESSION_MAX_AGE_MS;
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === currentSessionId)
+                continue;
+            const dir = path.join(base, entry.name);
+            try {
+                if (fs.statSync(dir).mtimeMs >= deadline)
+                    continue;
+                fs.rmSync(dir, { recursive: true, force: true });
+                this.log.write("debug", `hook: pruned stale session directory: ${dir}`);
+            }
+            catch (_e) {
+                /*  best-effort: ignore vanished or undeletable directories  */
+            }
+        }
+    }
     /*  drain and discard the stdin event payload  */
     async drainStdin() {
         await readStdin().catch(() => "");
@@ -176,14 +214,14 @@ export default class HookCommand {
         try {
             pkg = fs.readFileSync(filePkg, "utf8");
         }
-        catch (_e) {
-            throw new Error(`failed to read plugin manifest: ${filePkg}`);
+        catch (err) {
+            throw new Error(`failed to read plugin manifest: ${filePkg}`, { cause: err });
         }
         try {
             md = fs.readFileSync(fileMd, "utf8");
         }
-        catch (_e) {
-            throw new Error(`failed to read constitution file: ${fileMd}`);
+        catch (err) {
+            throw new Error(`failed to read constitution file: ${fileMd}`, { cause: err });
         }
         /*  determine own version  */
         const pkgObj = this.parseJSON(pkg, v.object({ version: v.optional(v.string()) }));
@@ -210,6 +248,8 @@ export default class HookCommand {
         }));
         /*  determine session id  */
         const sessionId = this.pickSessionId(input);
+        /*  garbage-collect orphaned session directories of previous agent runs  */
+        this.pruneStaleSessions(sessionId);
         /*  establish config context (session-scoped only if a valid sessionId is present)  */
         const hasSession = this.isValidSessionId(sessionId);
         const cfg = new Config("config", configSchema, this.log, hasSession ? parseScope(`session:${sessionId}`) : parseScope(undefined));
@@ -363,7 +403,7 @@ export default class HookCommand {
         const sessionId = await this.readSessionIdFromStdin();
         /*  remove the session directory ~/.ase/session/<id> (only for a valid sessionId)  */
         if (this.isValidSessionId(sessionId)) {
-            const dir = path.join(os.homedir(), ".ase", "session", sessionId);
+            const dir = path.join(this.sessionBaseDir(), sessionId);
             try {
                 fs.rmSync(dir, { recursive: true, force: true });
             }

package/dst/ase-markdown.js

@@ -215,7 +215,7 @@ export class Markdown {
             }
             if (fence > 0 && (ch === "\r" || ch === "\n")) {
                 /*  consume optional CR followed by mandatory LF  */
-                let nl = "";
+                let nl;
                 if (ch === "\r" && i + 1 < text.length && text[i + 1] === "\n") {
                     nl = "\r\n";
                     i += 2;

package/dst/ase-meta.js

@@ -41,7 +41,7 @@ export class Meta {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            throw new Error(`meta: failed to read file: ${abs} (${message})`);
+            throw new Error(`meta: failed to read file: ${abs} (${message})`, { cause: err });
         }
     }
 }

package/dst/ase-service.js

@@ -27,6 +27,7 @@ import { TimestampMCP } from "./ase-timestamp.js";
 import { SleepMCP } from "./ase-sleep.js";
 import { GetoptMCP } from "./ase-getopt.js";
 import { SkillsMCP } from "./ase-skills.js";
+import { WorktreeMCP } from "./ase-worktree.js";
 import pkg from "../package.json" with { type: "json" };
 /*  shared service host  */
 export const SERVICE_HOST = "127.0.0.1";
@@ -272,6 +273,7 @@ export default class ServiceCommand {
             new SleepMCP().register(mcp);
             new GetoptMCP().register(mcp);
             new SkillsMCP().register(mcp);
+            new WorktreeMCP().register(mcp);
             new ConfigMCP(this.log).register(mcp);
             return mcp;
         };

package/dst/ase-setup.js

@@ -47,7 +47,7 @@ export default class SetupCommand {
             return false;
         /*  determine the npm global prefix and probe writability of the
             directories that "npm -g" actually mutates  */
-        let prefix = "";
+        let prefix;
         try {
             const result = await execa("npm", ["prefix", "-g"], { stdio: "pipe" });
             prefix = result.stdout.trim();

package/dst/ase-sleep.js

@@ -10,11 +10,11 @@ export class SleepMCP {
         mcp.registerTool("ase_sleep", {
             title: "ASE sleep",
             description: "Wait once for `duration` seconds and then return. " +
-                "The duration can be fractional (e.g. `1.5`). " +
+                "The duration can be fractional (e.g. `1.5`) and is at most 120 (default: 60). " +
                 "Returns `OK: slept <duration> seconds` as `text` after the duration elapsed.",
             inputSchema: {
-                duration: z.number().positive().max(3600)
-                    .describe("wait duration in seconds (fractional values allowed, at most 3600)")
+                duration: z.number().positive().max(120).default(60)
+                    .describe("wait duration in seconds (fractional values allowed, at most 120, default 60)")
             }
         }, async (args) => {
             await new Promise((resolve) => setTimeout(resolve, args.duration * 1000));

package/dst/ase-statusline.js

@@ -229,7 +229,7 @@ export default class StatuslineCommand {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                throw new Error(`statusline: invalid JSON on stdin: ${message}`);
+                throw new Error(`statusline: invalid JSON on stdin: ${message}`, { cause: err });
             }
             /*  normalize Copilot CLI's top-level "cwd" into the
                 "workspace.current_dir" structure shared with Anthropic Claude Code CLI  */

package/dst/ase-worktree.js

@@ -0,0 +1,162 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+import path from "node:path";
+import fs from "node:fs";
+import { execaSync } from "execa";
+import { z } from "zod";
+import { writeStdout } from "./ase-stdio.js";
+/*  the repository-root-relative path components of the base directory
+    which holds all ASE-managed Git worktrees  */
+const baseComponents = [".ase", "worktree"];
+/*  reusable functionality: safe resolution of the ASE worktree
+    directories under <repo-root>/.ase/worktree/<id>  */
+export class Worktree {
+    /*  validate a worktree id to keep it safe both as a single path
+        component and as the Git branch name derived from it  */
+    static validateId(id) {
+        if (typeof id !== "string" || id.length === 0)
+            throw new Error("worktree: id must be a non-empty string");
+        if (!/^[A-Za-z0-9_-]+$/.test(id))
+            throw new Error("worktree: id must match [A-Za-z0-9_-]+");
+    }
+    /*  determine the fully resolved top-level directory of the Git
+        working tree, as a Git worktree can only be created from
+        inside one  */
+    static repoRoot() {
+        let top = "";
+        try {
+            top = execaSync("git", ["rev-parse", "--show-toplevel"], { stderr: "ignore" }).stdout.trim();
+        }
+        catch {
+            /*  not inside a Git working tree  */
+        }
+        if (top === "")
+            throw new Error("worktree: not inside a Git working tree -- cannot create a worktree");
+        return fs.realpathSync(top);
+    }
+    /*  assert that an already existing path is a real, non-aliased
+        directory: "git worktree add" silently follows a symlinked path
+        component, so a repository carrying a committed ".ase" or
+        ".ase/worktree" symlink would make it write outside the
+        repository entirely  */
+    static assertRealDir(dir) {
+        let st;
+        try {
+            st = fs.lstatSync(dir);
+        }
+        catch {
+            /*  a not yet existing path component is created later on  */
+            return;
+        }
+        if (st.isSymbolicLink())
+            throw new Error(`worktree: "${dir}" is a symbolic link -- ` +
+                "refusing to create a worktree through it");
+        if (!st.isDirectory())
+            throw new Error(`worktree: "${dir}" exists but is not a directory`);
+        const real = fs.realpathSync(dir);
+        if (real !== dir)
+            throw new Error(`worktree: "${dir}" resolves to "${real}" -- ` +
+                "refusing to create a worktree through an aliased path");
+    }
+    /*  resolve the base directory holding all ASE worktrees, asserting
+        that every path component below the repository root is a real
+        directory; the base directory is created on demand only  */
+    static baseDir(create = false) {
+        let dir = Worktree.repoRoot();
+        for (const component of baseComponents) {
+            dir = path.join(dir, component);
+            Worktree.assertRealDir(dir);
+        }
+        if (create) {
+            fs.mkdirSync(dir, { recursive: true });
+            Worktree.assertRealDir(dir);
+        }
+        return dir;
+    }
+    /*  resolve the worktree directory of a single id; the leaf itself is
+        created by "git worktree add" and hence only has to be free of an
+        aliasing entry left behind by an earlier run  */
+    static dir(id, create = false) {
+        Worktree.validateId(id);
+        const dir = path.join(Worktree.baseDir(create), id);
+        Worktree.assertRealDir(dir);
+        return dir;
+    }
+}
+/*  CLI command "ase worktree"  */
+export default class WorktreeCommand {
+    /*  register commands  */
+    register(program) {
+        /*  register CLI top-level command "ase worktree"  */
+        const worktree = program
+            .command("worktree")
+            .description("Safely resolve the ASE worktree directories under <repo-root>/.ase/worktree")
+            .action(() => {
+            worktree.outputHelp();
+            process.exit(1);
+        });
+        /*  register CLI sub-command "ase worktree base"  */
+        worktree
+            .command("base")
+            .description("Print the validated base directory holding all ASE worktrees")
+            .option("-c, --create", "create the base directory if it does not exist yet")
+            .action(async (opts) => {
+            await writeStdout(`${Worktree.baseDir(opts.create ?? false)}\n`);
+        });
+        /*  register CLI sub-command "ase worktree path"  */
+        worktree
+            .command("path")
+            .description("Print the validated worktree directory of a single <id>")
+            .argument("<id>", "Worktree identifier")
+            .option("-c, --create", "create the base directory if it does not exist yet")
+            .action(async (id, opts) => {
+            await writeStdout(`${Worktree.dir(id, opts.create ?? false)}\n`);
+        });
+    }
+}
+/*  render a caught error as an MCP tool error result  */
+const mcpToolError = (err) => ({
+    isError: true,
+    content: [{ type: "text", text: `ERROR: ${err instanceof Error ? err.message : String(err)}` }]
+});
+/*  MCP registration entry point for worktree tools  */
+export class WorktreeMCP {
+    register(mcp) {
+        mcp.registerTool("ase_worktree_path", {
+            title: "ASE worktree path",
+            description: "Resolve the absolute, validated directory of an ASE-managed Git worktree. " +
+                "Returns `<repo-root>/.ase/worktree/<id>` as `text` if `id` is given, and the " +
+                "base directory `<repo-root>/.ase/worktree` otherwise. " +
+                "You MUST call this to obtain the directory of every worktree instead of " +
+                "assembling the path yourself: it rejects a path leading through a symbolic " +
+                "link, through a non-directory, or out of the repository, which `git worktree " +
+                "add` would otherwise silently follow and thereby write outside the repository. " +
+                "Set `create` to `true` to also create the base directory. " +
+                "Fails with an error if the path is unsafe or the current directory is not a " +
+                "Git working tree; in that case you MUST NOT create the worktree at all.",
+            inputSchema: {
+                id: z.string().optional()
+                    .describe("worktree identifier (allowed characters: A-Z, a-z, 0-9, '_', '-'); " +
+                    "if omitted, the base directory holding all ASE worktrees is returned"),
+                create: z.boolean().optional()
+                    .describe("if true, create the base directory if it does not exist yet (default: false)")
+            }
+        }, async (args) => {
+            try {
+                const create = args.create ?? false;
+                const text = args.id !== undefined ?
+                    Worktree.dir(args.id, create) :
+                    Worktree.baseDir(create);
+                return {
+                    content: [{ type: "text", text }]
+                };
+            }
+            catch (err) {
+                return mcpToolError(err);
+            }
+        });
+    }
+}

package/dst/ase.js

@@ -17,6 +17,7 @@ import ArtifactCommand from "./ase-artifact.js";
 import MetaCommand from "./ase-meta.js";
 import CompatCommand from "./ase-compat.js";
 import DiagramCommand from "./ase-diagram.js";
+import WorktreeCommand from "./ase-worktree.js";
 import pkg from "../package.json" with { type: "json" };
 /*  globally initialize logger  */
 const log = new Log("ase", "info", "-");
@@ -56,6 +57,7 @@ const main = async () => {
     new MetaCommand(log).register(program);
     new CompatCommand().register(program);
     new DiagramCommand(log).register(program);
+    new WorktreeCommand().register(program);
     /*  parse program arguments  */
     await program.parseAsync(process.argv);
     /*  gracefully terminate  */

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.58",
+    "version":                              "0.9.60",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -16,22 +16,22 @@
     "type":                                 "module",
     "bin":                                  { "ase": "bin/ase" },
     "devDependencies": {
-        "eslint":                           "9.39.4",
-        "@eslint/js":                       "9.39.4",
-        "@typescript-eslint/parser":        "8.66.0",
-        "@typescript-eslint/eslint-plugin": "8.66.0",
+        "eslint":                           "10.9.0",
+        "@eslint/js":                       "10.0.1",
+        "@typescript-eslint/parser":        "8.67.0",
+        "@typescript-eslint/eslint-plugin": "8.67.0",
+        "typescript-eslint":                "8.67.0",
         "eslint-plugin-promise":            "7.3.0",
-        "eslint-plugin-import":             "2.32.0",
-        "neostandard":                      "0.13.0",
-        "globals":                          "17.9.0",
+        "neostandard":                      "0.14.0-next.1",
+        "globals":                          "17.11.0",
         "typescript":                       "6.0.3",
 
         "@rse/stx":                         "1.1.6",
         "nodemon":                          "3.1.14",
         "shx":                              "0.4.0",
 
-        "@types/node":                      "26.1.2",
-        "@types/luxon":                     "3.7.3",
+        "@types/node":                      "26.2.0",
+        "@types/luxon":                     "3.7.5",
         "@types/which":                     "3.0.4",
         "@types/update-notifier":           "6.0.8",
         "@types/shell-quote":               "1.7.5",
@@ -42,7 +42,7 @@
     },
     "dependencies": {
         "commander":                        "15.0.0",
-        "@dotenvx/dotenvx":                 "2.19.2",
+        "@dotenvx/dotenvx":                 "2.21.0",
         "yaml":                             "2.9.0",
         "valibot":                          "1.4.2",
         "execa":                            "10.0.1",
@@ -72,9 +72,8 @@
     },
     "engines": {
         "npm":                              ">=10.0.0",
-        "node":                             ">=22.0.0"
+        "node":                             ">=22.13.0"
     },
-    "upd":                                  [ "!eslint", "!@eslint/js" ],
     "files": [
         "dst/**/*",
         "bin/**/*",

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

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

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

@@ -334,6 +334,12 @@ Workflow
                 pure-insertion hunk at its new location - *never* by
                 deleting and re-adding the unchanged lines in between.
 
+                This minimality rule applies *only* to <old-text/> and
+                <new-text/>. It *MUST* *NOT* be understood as a reason to
+                also drop the surrounding context of the two following
+                substeps - that context is *mandatory* and is reported
+                *separately* from the changed lines.
+
             3.  Set <context-before/> to exactly *up to two* lines of
                 *unchanged* code context which occurs in <file/>
                 directly *before* <old-text/>, i.e., the lines (<line/>
@@ -365,6 +371,15 @@ Workflow
                     }
                 </template>
 
+                Here `line` is a *number* and all four other fields are
+                *JSON strings* carrying the *verbatim* source lines
+                (embedded newlines escaped as `\n`, no line-number
+                prefixes, original indentation preserved). The empty
+                string `""` is allowed for `context_before` and
+                `context_after` *only* at the very start or end of the
+                file - for every other hunk both *MUST* carry their
+                context lines.
+
         3.  If <change-set/> is not empty, set
             <change-set><change-set/>,</change-set> (append a comma).
             Then append the following <template/> to <change-set/>:

package/plugin/agents/ase-docs-proofread.md

@@ -50,6 +50,12 @@ Workflow
         as *two separate* problems instead of one large change
         which re-states the unchanged lines.
 
+        This minimality rule applies *only* to <old-text/> and
+        <new-text/>. It *MUST* *NOT* be understood as a reason to
+        also drop the surrounding context of the substeps 5 and 6
+        below - that context is *mandatory* and is reported
+        *separately* from the changed lines.
+
     4.  Set <description/> to an ultra-brief and concise
         Markdown-formatted description of the problem with
         a hint of what is wrong and why it is wrong. In
@@ -94,6 +100,15 @@ Workflow
             }
         </template>
 
+        Here `line` is a *number* and all other fields are *JSON
+        strings*, where <context-before/>, <old-text/>, <new-text/>,
+        and <context-after/> carry the *verbatim* document lines
+        (embedded newlines escaped as `\n`, no line-number prefixes,
+        original indentation preserved). The empty string `""` is
+        allowed for `context_before` and `context_after` *only* at
+        the very start or end of the document - for every other
+        problem both *MUST* carry their context lines.
+
 3.  You *MUST* *NOT* propose, apply, or render any document
     changes yourself. Instead, return *exclusively* as the last message
     a single JSON block (no markdown, no prose, no preamble, no summary)

package/plugin/meta/ase-common-code.md

@@ -138,7 +138,7 @@ Set <args>--int-reuse-task</args>.
     <template/> and then *STOP*. Do *not* implement the plan.
 
     <template>
-    ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- done**
+    ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan finalized -- done**
     </template>
     </if>
 

package/plugin/meta/ase-common-task.md

@@ -83,16 +83,14 @@ Task Skill Common Steps
 
 -   If <text/> starts with `ERROR:` or `WARNING:`:
     Set <task-content></task-content> (set task content to empty).
-    Set <words/> to "0".
 
 -   If <text/> does NOT start with `ERROR:` and NOT with `WARNING:`:
     Set <task-content><text/></task-content> (set task content to text).
-    Calculate the number of words <words/> of <task-content/>.
 
 Only output the following <template/>:
 
 <template>
-⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **<status/>**
+⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **<status/>**
 </template>
 
 </define>
@@ -109,16 +107,18 @@ had no `Created:` frontmatter key), set
 (fall back to the modified timestamp). Re-insert the current
 <ase-task-id/>, the original <timestamp-created/>, and the
 refreshed <timestamp-modified/> into the frontmatter keys `Id:`,
-`Created:`, and `Modified:` of <task-content/> and calculate
-the number of words <words/> of <task-content/>.
+`Created:`, and `Modified:` of <task-content/>.
 
 Call the `ase_task_save(id: "<ase-task-id/>", text:
 "<task-content/>")` tool of the `ase` MCP server to save the task
-plan content in its *authoring form*. Do not output anything
+plan content in its *authoring form*. This `ase_task_save` MCP
+tool call is the *only* permitted way to persist the task plan --
+you *MUST* *NEVER* write the plan file via `Write`/`Edit` or by
+executing a shell command. Do not output anything
 related to this MCP call except the following <template/>:
 
 <template>
-⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **<arg1/>**
+⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **<arg1/>**
 </template>
 
 </define>
@@ -169,7 +169,7 @@ Only output the following <template/> and then call the tool
 stop processing the current skill once the `Skill` tool was used.
 
 <template>
-⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **<arg2/>**
+⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **<arg2/>**
 </template>
 
 </define>

package/plugin/meta/ase-control.md

@@ -99,10 +99,18 @@ Control Flow Constructs
     <sleep duration="<sleep-duration/>"/>:
 
     This specifies a single *wait* of <sleep-duration/> seconds
-    (fractional values like `1.5` are allowed): call the
-    `ase_sleep(duration: <sleep-duration/>)` tool of the `ase` MCP
-    server, which returns once the duration has elapsed. This construct
-    is expanded into nothing. Do not output anything.
+    (fractional values like `1.5` are allowed).
+
+    The wait is performed with the `ase_sleep(duration:
+    <chunk-duration/>)` tool of the `ase` MCP server, which returns once
+    <chunk-duration/> has elapsed. To stay safely inside the tool's own
+    duration limit, <chunk-duration/> is *never* above `60`: a
+    <sleep-duration/> above `60` is therefore *split* into consecutive
+    calls -- as many `60` second calls as fit, followed by one final
+    call carrying the remaining seconds -- so the calls sum up to
+    exactly <sleep-duration/>.
+
+    This construct is expanded into nothing. Do not output anything.
 
 -   *IMPORTANT*: You *MUST* honor the following control flow construct:
     <await condition="<await-condition/>" [interval="<await-interval/>"]><await-body/></await>:
@@ -111,10 +119,20 @@ Control Flow Constructs
     <await-condition/> is met: if <await-condition/> is met, the
     <await-body/> is executed once and the construct is finished. If
     <await-condition/> is *not* met, wait for <await-interval/> seconds
-    (default: `60`) via the `ase_sleep(duration: <await-interval/>)`
-    tool of the `ase` MCP server and then *start over* by re-evaluating
-    <await-condition/>. This construct is expanded to its
-    <await-body/>. Do not output anything else.
+    (default: `60`) and then *start over* by re-evaluating
+    <await-condition/>.
+
+    A single wait is performed with the `ase_sleep(duration:
+    <chunk-duration/>)` tool of the `ase` MCP server. To stay safely
+    inside the tool's own duration limit, <chunk-duration/> is *never*
+    above `60`: an <await-interval/> above `60` is therefore *split* into
+    consecutive calls -- as many `60` second calls as fit, followed by
+    one final call carrying the remaining seconds -- so the calls sum up
+    to exactly <await-interval/>. You *MUST* *NOT* re-evaluate
+    <await-condition/> between the calls of one such wait.
+
+    This construct is expanded to its <await-body/>. Do not output
+    anything else.
 
 -   *IMPORTANT*: You *MUST* honor the following control flow construct:
     <agent <attr/>="<value/>" [...]><agent-body/></agent>:

package/plugin/meta/ase-dialog.md

@@ -102,8 +102,10 @@ following procedure:
         </ase-tpl-boxed>
         </text>
 
-        If <n/> is less than 2:
-        Set <result>ERROR: custom-dialog requires 2-9 answer lines, got <n/></result>
+        If <n/> is less than 2 -- or less than 1 when <opts/> contains
+        `--other` and does *not* contain `--no-other`, as the free-text
+        path then complements a single answer option:
+        Set <result>ERROR: custom-dialog requires 2-9 (with free-text: 1-9) answer lines, got <n/></result>
         and *SKIP* the following step 2.2 and continue with step 2.3 dispatch.
 
     2.  Output the following <template/>, end the current turn, wait for the

package/plugin/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.58",
+    "version":                              "0.9.60",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -17,13 +17,13 @@
         "@rse/stx":                         "1.1.6",
         "markdownlint":                     "0.41.1",
         "markdownlint-cli2":                "0.23.2",
-        "eslint":                           "10.8.0",
+        "eslint":                           "10.9.0",
         "@eslint/markdown":                 "8.0.3",
-        "eslint-markdown":                  "0.13.0"
+        "eslint-markdown":                  "0.14.0"
     },
     "engines": {
         "npm":                              ">=10.0.0",
-        "node":                             ">=22.0.0"
+        "node":                             ">=22.13.0"
     },
     "scripts": {
         "start":                            "stx -v4 -l warning -c etc/stx.conf"