@rse/ase 1.0.4 → 1.0.5

package/dst/ase-artifact.js

@@ -10,6 +10,7 @@ import { isScalar } from "yaml";
 import { z } from "zod";
 import { Config, configSchema } from "./ase-config.js";
 import { Task } from "./ase-task.js";
+import { Ignore } from "./ase-ignore.js";
 import { writeStdout } from "./ase-stdio.js";
 /*  the recognized artifact kinds, in descending precedence order;
     "othr" is the implicit catch-all and is always resolved last  */
@@ -26,72 +27,22 @@ export class Artifact {
                 `(expected one of: ${artifactKinds.join(", ")})`);
         return kind;
     }
-    /*  translate a single ".gitignore" line into a picomatch-backed rule,
-        honoring the anchored-vs-floating, directory-only, and negation
-        semantics of ".gitignore" patterns; anchored patterns resolve
-        relative to the "base" directory holding the ".gitignore"  */
-    static compileIgnoreRule(line, base) {
-        let pattern = line.trim();
-        if (pattern === "" || pattern.startsWith("#"))
-            return null;
-        let negated = false;
-        if (pattern.startsWith("!")) {
-            negated = true;
-            pattern = pattern.slice(1);
-        }
-        let dirOnly = false;
-        if (pattern.endsWith("/")) {
-            dirOnly = true;
-            pattern = pattern.slice(0, -1);
-        }
-        const anchored = pattern.includes("/");
-        if (pattern.startsWith("/"))
-            pattern = pattern.slice(1);
-        const glob = anchored ? (base === "" ? pattern : `${base}/${pattern}`) : `**/${pattern}`;
-        const isMatch = picomatch(glob, { dot: true });
-        return { matcher: (p) => isMatch(p), negated, dirOnly };
-    }
-    /*  load the ".gitignore" rules located directly in a directory,
-        given as absolute "dir" and project-relative "relDir"  */
-    static loadIgnoreRules(dir, relDir) {
-        const file = path.join(dir, ".gitignore");
-        if (!fs.existsSync(file))
-            return [];
-        const rules = [];
-        for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
-            const rule = Artifact.compileIgnoreRule(line, relDir);
-            if (rule !== null)
-                rules.push(rule);
-        }
-        return rules;
-    }
-    /*  decide whether a project-relative path is ignored by the given
-        ordered ".gitignore" rule set (last matching rule wins)  */
-    static isIgnored(rel, isDir, rules) {
-        let ignored = false;
-        for (const rule of rules) {
-            if (rule.dirOnly && !isDir)
-                continue;
-            if (rule.matcher(rel))
-                ignored = !rule.negated;
-        }
-        return ignored;
-    }
     /*  build the file universe by walking the project tree from the
-        project root, honoring ".gitignore" rules (root plus nested) and
-        always pruning ".git". Yields POSIX project-relative, sorted,
+        project root, honoring the Git exclude rules (the repository-wide
+        ones plus the root and nested ".gitignore" files) and always
+        pruning ".git". Yields POSIX project-relative, sorted,
         de-duplicated file paths  */
     static universe() {
         const root = Task.projectRoot();
         const files = new Set();
         const walk = (dir, relDir, inherited) => {
-            const rules = [...inherited, ...Artifact.loadIgnoreRules(dir, relDir)];
+            const rules = [...inherited, ...Ignore.rules(dir, relDir)];
             for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
                 if (entry.name === ".git")
                     continue;
                 const rel = relDir === "" ? entry.name : `${relDir}/${entry.name}`;
                 const isDir = entry.isDirectory();
-                if (Artifact.isIgnored(rel, isDir, rules))
+                if (Ignore.matches(rel, isDir, rules))
                     continue;
                 if (isDir)
                     walk(path.join(dir, entry.name), rel, rules);
@@ -99,7 +50,7 @@ export class Artifact {
                     files.add(rel);
             }
         };
-        walk(root, "", []);
+        walk(root, "", Ignore.base(root));
         return [...files].sort((a, b) => a.localeCompare(b));
     }
     /*  raw-resolve a single kind's configuration spec against the file

package/dst/ase-config.js

@@ -10,12 +10,12 @@ import readline from "node:readline/promises";
 import { Document, parseDocument, isMap, isScalar } from "yaml";
 import { execaSync } from "execa";
 import * as v from "valibot";
-import Table from "cli-table3";
 import writeFileAtomic from "write-file-atomic";
 import lockfile from "proper-lockfile";
 import { z } from "zod";
 import { LRUCache } from "lru-cache";
 import { writeStdout } from "./ase-stdio.js";
+import { renderTable } from "./ase-table.js";
 /*  classification taxonomy  */
 export const projectClassification = {
     boxing: ["white", "grey", "black"]
@@ -184,7 +184,8 @@ const artifactSchema = v.optional(v.strictObject({
     files: v.optional(v.string())
 }));
 /*  schema for the "spec" artifact kind, additionally carrying the
-    SpecBook YAML "schema" configuration file (empty: bundled standard)  */
+    whitespace-separated list of SpecBook YAML "schema" configuration
+    files, with "std" naming the bundled standard one (empty: "std")  */
 const artifactSpecSchema = v.optional(v.strictObject({
     basedir: v.optional(v.string()),
     files: v.optional(v.string()),
@@ -632,16 +633,12 @@ export default class ConfigCommand {
             const scope = parseScope(cmd.optsWithGlobals().scope);
             const cfg = new Config("config", configSchema, this.log, scope);
             cfg.read();
-            const table = new Table({
-                head: ["KEY", "VALUE", "SCOPE"],
-                chars: { "mid": "", "left-mid": "", "mid-mid": "", "right-mid": "" },
-                style: { head: ["blue"] }
-            });
+            const rows = [];
             for (const e of cfg.entries()) {
                 const val = isScalar(e.value) ? e.value.value : e.value;
-                table.push([e.key, String(val), Config.scopeLabel(e.scope)]);
+                rows.push([e.key, String(val), Config.scopeLabel(e.scope)]);
             }
-            await writeStdout(`${table.toString()}\n`);
+            await writeStdout(renderTable(["KEY", "VALUE", "SCOPE"], rows));
         });
         /*  register CLI sub-command "ase config edit"  */
         configCmd

package/dst/ase-hook.js

@@ -292,8 +292,8 @@ export default class HookCommand {
         const persona = setting("agent.persona", "ASE_PERSONA_STYLE", "engineer");
         const guidance = setting("agent.guidance", "ASE_GUIDANCE_LEVEL", "normal");
         const boxing = setting("project.boxing", "ASE_PROJECT_BOXING", "white");
-        /*  determine the specification base directory and the SpecBook
-            schema configuration (empty: the bundled standard schema)  */
+        /*  determine the specification base directory and the whitespace-separated
+            list of SpecBook schema configurations (empty: the bundled standard schema)  */
         const specBasedir = String(cfg.get("project.artifact.spec.basedir") ?? "");
         const specSchema = String(cfg.get("project.artifact.spec.schema") ?? "");
         /*  determine headless mode  */

package/dst/ase-ignore.js

@@ -0,0 +1,129 @@
+/*
+**  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 os from "node:os";
+import fs from "node:fs";
+import { execaSync } from "execa";
+import picomatch from "picomatch";
+import { LRUCache } from "lru-cache";
+/*  reusable functionality: decide which project-relative paths Git
+    excludes from the project, honoring the same three rule sources and
+    the same precedence order as Git itself -- the global excludes file,
+    the repository-local "info/exclude", and the per-directory
+    ".gitignore" files from the project root down to the path  */
+export class Ignore {
+    /*  translate a single Git exclude line into a picomatch-backed rule,
+        honoring the anchored-vs-floating, directory-only, and negation
+        semantics of the pattern; an anchored pattern resolves relative
+        to the "base" directory its rule file governs  */
+    static compile(line, base) {
+        let pattern = line.trim();
+        if (pattern === "" || pattern.startsWith("#"))
+            return null;
+        let negated = false;
+        if (pattern.startsWith("!")) {
+            negated = true;
+            pattern = pattern.slice(1);
+        }
+        let dirOnly = false;
+        if (pattern.endsWith("/")) {
+            dirOnly = true;
+            pattern = pattern.slice(0, -1);
+        }
+        const anchored = pattern.includes("/");
+        if (pattern.startsWith("/"))
+            pattern = pattern.slice(1);
+        const glob = anchored ? (base === "" ? pattern : `${base}/${pattern}`) : `**/${pattern}`;
+        const isMatch = picomatch(glob, { dot: true });
+        return { matcher: (p) => isMatch(p), negated, dirOnly };
+    }
+    /*  load the rules of a single exclude file, given as absolute "file"
+        and the project-relative "base" its anchored patterns resolve
+        against; a missing file simply contributes no rules  */
+    static load(file, base) {
+        if (file === "" || !fs.existsSync(file))
+            return [];
+        const rules = [];
+        for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
+            const rule = Ignore.compile(line, base);
+            if (rule !== null)
+                rules.push(rule);
+        }
+        return rules;
+    }
+    /*  load the ".gitignore" rules located directly in a directory,
+        given as absolute "dir" and project-relative "relDir"  */
+    static rules(dir, relDir) {
+        return Ignore.load(path.join(dir, ".gitignore"), relDir);
+    }
+    /*  resolve the global Git excludes file: the configured
+        "core.excludesFile", or else the XDG location Git falls back
+        onto when that configuration value is unset  */
+    static globalFile() {
+        let file = "";
+        try {
+            file = execaSync("git", ["config", "--get", "core.excludesFile"], { stderr: "ignore" }).stdout.trim();
+        }
+        catch {
+            /*  no such configuration value  */
+        }
+        if (file === "") {
+            const xdg = process.env.XDG_CONFIG_HOME;
+            return xdg !== undefined && xdg !== "" ?
+                path.join(xdg, "git", "ignore") :
+                path.join(os.homedir(), ".config", "git", "ignore");
+        }
+        if (file.startsWith("~/"))
+            file = path.join(os.homedir(), file.slice(2));
+        return file;
+    }
+    /*  resolve the repository-local exclude file, held by the Git
+        *common* directory, so that a Git worktree shares the exclude
+        file of the main working tree it was created from  */
+    static infoFile(root) {
+        try {
+            const dir = execaSync("git", ["rev-parse", "--git-common-dir"], { cwd: root, stderr: "ignore" }).stdout.trim();
+            if (dir !== "")
+                return path.join(path.resolve(root, dir), "info", "exclude");
+        }
+        catch {
+            /*  not inside a Git working tree  */
+        }
+        return "";
+    }
+    /*  cached repository-wide rules (TTL-bounded, as the ASE service is
+        long-running and both the Git configuration and the exclude files
+        can change underneath it; each determination spawns Git, too)  */
+    static baseCache = new LRUCache({ max: 4, ttl: 10 * 1000 });
+    /*  the rules which no directory of the project owns and which hence
+        govern the project as a whole, in ascending Git precedence: the
+        global excludes file first, the repository-local "info/exclude"
+        second, so a later rule overrides an earlier one as it does in
+        Git; both anchor their patterns at the project root  */
+    static base(root) {
+        const cached = Ignore.baseCache.get(root);
+        if (cached !== undefined)
+            return cached;
+        const rules = [
+            ...Ignore.load(Ignore.globalFile(), ""),
+            ...Ignore.load(Ignore.infoFile(root), "")
+        ];
+        Ignore.baseCache.set(root, rules);
+        return rules;
+    }
+    /*  decide whether a project-relative path is excluded by the given
+        ordered rule set, where the last matching rule wins  */
+    static matches(rel, isDir, rules) {
+        let ignored = false;
+        for (const rule of rules) {
+            if (rule.dirOnly && !isDir)
+                continue;
+            if (rule.matcher(rel))
+                ignored = !rule.negated;
+        }
+        return ignored;
+    }
+}

package/dst/ase-setup.js

@@ -10,12 +10,12 @@ 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 writeFileAtomic from "write-file-atomic";
 import { mkdirp } from "mkdirp";
 import JsonAsty from "json-asty";
 import Version from "./ase-version.js";
+import { renderTable } from "./ase-table.js";
 const toolSpecs = {
     "claude": { cli: "claude", label: "Anthropic Claude Code CLI", pInstall: "install", pRemove: "uninstall", pUpdate: "update" },
     "copilot": { cli: "copilot", label: "GitHub Copilot CLI", pInstall: "install", pRemove: "uninstall", pUpdate: "update" },
@@ -245,21 +245,15 @@ export default class SetupCommand {
         const spec = toolSpecs[tool];
         await this.ensureTool(spec.cli);
         this.log.write("info", `setup: status: probing ASE registrations for ${spec.label}`);
-        const table = new Table({
-            head: ["KIND", "ID", "SCOPE", "STATUS"],
-            colWidths: [13, 34, 10, 16],
-            wordWrap: true,
-            chars: { "mid": "", "left-mid": "", "mid-mid": "", "right-mid": "" },
-            style: { head: ["blue"] }
-        });
+        const rows = [];
         /*  report the ASE plugin registrations, with an absent plugin
             still rendered as an explicit row instead of being omitted  */
         const plugins = await this.pluginStatus(tool);
         if (plugins.length === 0)
-            table.push(["PLUGIN", chalk.bold("ase@ase"), "(n/a)", "not installed"]);
+            rows.push(["PLUGIN", chalk.bold("ase@ase"), "(n/a)", "not installed"]);
         else
             for (const plugin of plugins)
-                table.push(["PLUGIN", chalk.bold("ase@ase"), plugin.scope, plugin.status]);
+                rows.push(["PLUGIN", chalk.bold("ase@ase"), plugin.scope, plugin.status]);
         /*  report the registered MCP servers, probed concurrently and
             silently skipping every server which is not registered at all  */
         const scopes = await Promise.all(this.mcpServers.map((handle) => this.mcpScope(tool, handle.server)));
@@ -267,12 +261,12 @@ export default class SetupCommand {
             const scope = scopes[i];
             if (scope === undefined)
                 continue;
-            table.push(["MCP", chalk.bold(this.mcpServers[i].server), scope, "registered"]);
+            rows.push(["MCP", chalk.bold(this.mcpServers[i].server), scope, "registered"]);
         }
         /*  report the ASE statusline registrations  */
         for (const statusline of await this.statuslineStatus(tool))
-            table.push(["STATUSLINE", chalk.bold(statusline.file), statusline.scope, statusline.status]);
-        process.stdout.write(`${table.toString()}\n`);
+            rows.push(["STATUSLINE", chalk.bold(statusline.file), statusline.scope, statusline.status]);
+        process.stdout.write(renderTable(["KIND", "ID", "SCOPE", "STATUS"], rows));
         return 0;
     }
     /*  probe the ASE plugin registrations by scraping the human-readable
@@ -323,15 +317,9 @@ export default class SetupCommand {
     }
     /*  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"] }
-        });
+        const rows = [];
         for (const handle of this.mcpServers)
-            table.push([
+            rows.push([
                 chalk.bold(handle.id),
                 handle.name,
                 handle.version ?? "(unknown)",
@@ -339,7 +327,7 @@ export default class SetupCommand {
                 handle.env.join(", "),
                 handle.skills.join(", ")
             ]);
-        process.stdout.write(`${table.toString()}\n`);
+        process.stdout.write(renderTable(["ID", "NAME", "VERS", "MCP", "KEY", "SKILLS"], rows));
         return 0;
     }
     /*  handler for "ase setup mcp activate|deactivate [<servers>]"  */

package/dst/ase-spec.js

@@ -18,18 +18,22 @@ import { writeStdout } from "./ase-stdio.js";
     project specification, located via the "project.artifact.spec.basedir"
     and "project.artifact.spec.schema" configuration  */
 export class Spec {
-    /*  resolve the YAML schema configuration files: the configured
-        "project.artifact.spec.schema" relative to the project root, or
-        the bundled standard "ase-format-specbook.yaml" plugin meta file
-        if unset or empty  */
+    /*  resolve the YAML schema configuration files: the whitespace-separated
+        entries of the configured "project.artifact.spec.schema", merged in
+        the given order, where each entry is either the literal "std" for the
+        bundled standard "ase-format-specbook.yaml" plugin meta file or a file
+        path relative to the project root, and an unset or empty value means "std"  */
     static configFiles(log) {
         const cfg = new Config("config", configSchema, log);
         cfg.read();
         const val = cfg.get("project.artifact.spec.schema");
-        const file = val === undefined ? "" : String(isScalar(val) ? val.value : val);
-        if (file === "")
-            return [Meta.resolve("ase-format-specbook.yaml")];
-        return [path.resolve(Task.projectRoot(), file)];
+        const list = val === undefined ? "" : String(isScalar(val) ? val.value : val);
+        const entries = list.split(/\s+/).filter((entry) => entry !== "");
+        if (entries.length === 0)
+            entries.push("std");
+        return entries.map((entry) => entry === "std" ?
+            Meta.resolve("ase-format-specbook.yaml") :
+            path.resolve(Task.projectRoot(), entry));
     }
     /*  the ASE log level each SpecBook verbosity level maps onto: the
         "none" level carries the messages a bare SpecBook CLI run always
@@ -80,12 +84,19 @@ export class Spec {
             return file;
         return rel.replace(/\\/g, "/");
     }
+    /*  every specification command honors the Git exclude rules, so that
+        SpecBook resolves the very same artifact files as "ase artifact
+        list --kind spec": both consult ".gitignore", so a specification
+        the project does not track is invisible to both instead of only
+        to one of them  */
+    static gitignore = true;
     /*  lint the specification Markdown files below the "spec" artifact
         base directory against the schema configuration  */
     static async lint(log) {
         const result = await Spec.unmarked(Spec.api(log).lint({
             config: Spec.configFiles(log),
-            basedir: Artifact.basedir(log, "spec")
+            basedir: Artifact.basedir(log, "spec"),
+            gitignore: Spec.gitignore
         }));
         return result.diagnostics.map((d) => ({ ...d, file: Spec.relativize(d.file) }));
     }
@@ -120,6 +131,7 @@ export class Spec {
         return Spec.unmarked(Spec.api(log, notices).export({
             config: Spec.configFiles(log),
             basedir: Artifact.basedir(log, "spec"),
+            gitignore: Spec.gitignore,
             formats
         }));
     }
@@ -131,6 +143,7 @@ export class Spec {
         return Spec.unmarked(Spec.api(log).watch({
             config: Spec.configFiles(log),
             basedir: Artifact.basedir(log, "spec"),
+            gitignore: Spec.gitignore,
             formats,
             outputs,
             onExport
@@ -143,6 +156,7 @@ export class Spec {
         return Spec.unmarked(Spec.api(log).preview({
             config: Spec.configFiles(log),
             basedir: Artifact.basedir(log, "spec"),
+            gitignore: Spec.gitignore,
             addr,
             port
         }));
@@ -246,7 +260,9 @@ export class SpecMCP {
             title: "ASE SpecBook lint",
             description: "Lint the SpecBook specification Markdown files of the project (located via the " +
                 "`project.artifact.spec.basedir` configuration) against the SpecBook YAML schema " +
-                "configuration (`project.artifact.spec.schema`, defaulting to the bundled `ase-format-specbook.yaml`). " +
+                "configuration (`project.artifact.spec.schema`, a whitespace-separated list of schema files " +
+                "merged in order, with `std` naming the bundled standard `ase-format-specbook.yaml`, " +
+                "which is also the default). " +
                 "Returns a `diagnostics` array of `{ file, line, column, severity, message }` objects (with " +
                 "project-relative `file` and a `severity` of `error` or `warning`), rendered as bullet " +
                 "points in `text`. With `verbose`, " +

package/dst/ase-table.js

@@ -0,0 +1,80 @@
+/*
+**  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 Table from "cli-table3";
+import { Diagram } from "./ase-diagram.js";
+/*  assumed terminal width in case the output is not a terminal at all  */
+const termWidthFallback = 80;
+/*  content width a column is at most shrunk down to, unless its own
+    content or its column head already is narrower anyway  */
+const colWidthMinimum = 8;
+/*  measure the visible width of a cell content, ignoring ANSI escape
+    sequences and honoring the longest line of a multi-line content  */
+const cellWidth = (text) => text.split("\n").reduce((width, line) => 
+/*  eslint-disable-next-line no-control-regex  */
+Math.max(width, line.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").length), 0);
+/*  check whether a cell content carries a single token which does not
+    fit the column and hence can be wrapped on character boundaries only  */
+const hasOverlongToken = (text, width) => text.split(/\s+/).some((token) => cellWidth(token) > width);
+/*  hard-break all over-long tokens of a cell content, so the content as
+    a whole can still be wrapped on its regular word boundaries; tokens
+    carrying ANSI escape sequences are left alone, as breaking them
+    would tear apart their escape sequences  */
+const breakOverlongTokens = (text, width) => text.split(/(\s+)/).map((token) => {
+    if (cellWidth(token) <= width || /\s/.test(token) || token.includes("\x1b"))
+        return token;
+    const chunks = [];
+    for (let i = 0; i < token.length; i += width)
+        chunks.push(token.slice(i, i + width));
+    return chunks.join("\n");
+}).join("");
+/*  reduce the column content widths until their sum fits the available
+    budget, by binary-searching the largest common upper cap which still
+    fits and which never cuts a column below its individual minimum  */
+const capWidths = (natural, minimum, budget) => {
+    const capped = (cap) => natural.map((width, i) => Math.max(Math.min(width, cap), Math.min(width, minimum[i])));
+    const total = (widths) => widths.reduce((sum, width) => sum + width, 0);
+    let lo = 1;
+    let hi = Math.max(...natural, 1);
+    while (lo < hi) {
+        const mid = Math.floor((lo + hi + 1) / 2);
+        if (total(capped(mid)) <= budget)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return capped(lo);
+};
+/*  render a table which never exceeds the terminal width, by wrapping
+    over-wide cell contents over multiple lines instead  */
+export const renderTable = (head, rows) => {
+    const cols = head.length;
+    /*  determine the natural, still unwrapped content width per column  */
+    const natural = head.map((text, i) => rows.reduce((width, row) => Math.max(width, cellWidth(row[i] ?? "")), cellWidth(text)));
+    /*  shrink the columns down to the width still remaining after the
+        border characters and the padding spaces of all columns  */
+    const term = Diagram.detectTermWidth() || termWidthFallback;
+    const budget = Math.max(term - (3 * cols + 1), cols);
+    const minimum = head.map((text) => Math.max(cellWidth(text), colWidthMinimum));
+    const widths = capWidths(natural, minimum, budget);
+    /*  render the table, falling back to wrapping on character
+        boundaries in just those cells where a token still overflows  */
+    const table = new Table({
+        head,
+        colWidths: widths.map((width) => width + 2),
+        wordWrap: true,
+        chars: { "mid": "", "left-mid": "", "mid-mid": "", "right-mid": "" },
+        style: { head: ["blue"] }
+    });
+    for (const row of rows)
+        table.push(row.map((text, i) => {
+            const content = breakOverlongTokens(text, widths[i]);
+            return {
+                content,
+                wrapOnWordBoundary: !hasOverlongToken(content, widths[i])
+            };
+        }));
+    return `${table.toString()}\n`;
+};

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":                              "1.0.4",
+    "version":                              "1.0.5",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -26,11 +26,11 @@
         "globals":                          "17.12.0",
         "typescript":                       "6.0.3",
 
-        "@rse/stx":                         "1.1.6",
+        "@rse/stx":                         "1.1.7",
         "nodemon":                          "3.1.14",
         "shx":                              "0.4.0",
 
-        "@types/node":                      "26.5.0",
+        "@types/node":                      "26.5.1",
         "@types/luxon":                     "3.7.5",
         "@types/which":                     "3.0.4",
         "@types/update-notifier":           "6.0.8",
@@ -42,8 +42,8 @@
     },
     "dependencies": {
         "commander":                        "15.0.0",
-        "@dotenvx/dotenvx":                 "2.23.0",
-        "yaml":                             "2.9.0",
+        "@dotenvx/dotenvx":                 "2.24.1",
+        "yaml":                             "2.9.1",
         "valibot":                          "1.5.0",
         "execa":                            "10.0.1",
         "mkdirp":                           "3.0.1",
@@ -55,7 +55,7 @@
         "luxon":                            "3.7.2",
         "@modelcontextprotocol/sdk":        "1.30.0",
         "json-asty":                        "1.3.4",
-        "zod":                              "4.6.1",
+        "zod":                              "4.6.4",
         "which":                            "7.0.0",
         "update-notifier":                  "7.3.1",
         "shell-quote":                      "1.10.0",
@@ -66,7 +66,7 @@
         "ofetch":                           "1.5.1",
         "picomatch":                        "4.0.7",
         "lru-cache":                        "11.5.2",
-        "@rse/specbook":                    "1.2.9",
+        "@rse/specbook":                    "1.2.10",
         "source-code-error":                "1.2.0",
         "pure-uuid":                        "2.0.0"
     },

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

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

package/plugin/meta/ase-format-spec.md

@@ -4,25 +4,30 @@
 SpecBook Project Instantiation
 ==============================
 
--   The **SpecBook SCHEMA Model** of this project depends on
-    the value of the <ase-spec-schema/> placeholder (holding the
-    `project.artifact.spec.schema` configuration value):
+-   The **SpecBook SCHEMA Model** of this project depends on the value
+    of the <ase-spec-schema/> placeholder (holding the
+    `project.artifact.spec.schema` configuration value), which is a
+    *whitespace-separated list* of schema entries, merged in the given
+    order into *one* **SpecBook SCHEMA Model**:
 
     -   If <ase-spec-schema/> is *empty*:
 
-        Then the **SpecBook SCHEMA Model** is the standard YAML
-        schema configuration bundled with **ASE** in the file
-        `meta/ase-format-specbook.yaml` (relative to the plugin root),
-        which you *MUST* read via the `Read` tool before working on the
-        specification of the **SpecBook SPEC Model**.
+        Then the list is treated as the single entry `std`.
 
-    -   If <ase-spec-schema/> is *not empty*:
+    -   For each entry `std` in the list:
 
-        Then the **SpecBook SCHEMA Model** is the custom YAML schema
-        configuration of the project in the file <ase-spec-schema/>
-        (relative to the project root), which you *MUST* read via
-        the `Read` tool before working on the specification of the
-        **SpecBook SPEC Model**.
+        The entry names the standard YAML schema configuration bundled
+        with **ASE** in the file `meta/ase-format-specbook.yaml`
+        (relative to the plugin root).
+
+    -   For each *other* entry in the list:
+
+        The entry names a custom YAML schema configuration file of the
+        project (relative to the project root).
+
+    You *MUST* read all resulting schema configuration files via the
+    `Read` tool before working on the specification of the **SpecBook
+    SPEC Model**.
 
 -   The **SpecBook SPEC Model** of this project is the set of specification
     Markdown files in the directory <ase-spec-basedir/> (relative

package/plugin/skills/ase-help-intent/data.md

@@ -3172,12 +3172,13 @@ Generate a user-wide skill and overwrite a previous generation:
 The `ase-spec-activate` skill activates the know-how about the
 *SpecBook*-based specification (`SPEC`) of the project in the current
 session: it loads the *SpecBook* format contract, reads the *SpecBook*
-schema configuration of the project (the standard schema bundled with
-*ASE*, or the custom schema configured via `project.artifact.spec.schema`),
-and resolves the list of `SPEC` artifacts in the configured specification
-base directory. The activation is reported in a `SPEC ACTIVATED` box,
-listing the schema file (marked `standard` or `custom`) and the base
-directory with the number of resolved artifacts.
+schema configuration of the project (the schema files configured via
+`project.artifact.spec.schema`, where the entry `std` -- also the default
+-- names the standard schema bundled with *ASE*), and resolves the list
+of `SPEC` artifacts in the configured specification base directory. The
+activation is reported in a `SPEC ACTIVATED` box, listing the schema
+files (each marked `standard` or `custom`) and the base directory with
+the number of resolved artifacts.
 
 Once activated, the specification can be worked with *ad-hoc* in plain
 conversation for the remainder of the session: reading, querying, and

package/plugin/skills/ase-spec-activate/SKILL.md

@@ -67,19 +67,21 @@ an ad-hoc change, and it *never* touches the artifact kinds `CODE`,
 
 3.  **Activate Schema:**
 
-    1.  Set <schema-file/> to the path of the **SpecBook SCHEMA Model**
-        of the project (resolved as described in `ase-format-spec.md`)
-        and <schema-kind/> to `standard` for the bundled schema or
-        `custom` for a project-specific one. Do not output anything.
-
-    2.  <if condition="the content of <schema-file/> was *not* already read into the current context -- neither by an earlier run of this skill nor by a dedicated specification skill">
-        Read the **SpecBook SCHEMA Model** in <schema-file/> via the
-        `Read` tool to learn the allowed object kinds, properties,
-        nestings, and value constraints. Do not output anything.
+    1.  Set <schema-files/> to the list of file paths constituting the
+        **SpecBook SCHEMA Model** of the project (resolved as described
+        in `ase-format-spec.md`), each annotated with `standard` for the
+        bundled schema or `custom` for a project-specific one. Do not
+        output anything.
+
+    2.  <if condition="the content of a file of <schema-files/> was *not* already read into the current context -- neither by an earlier run of this skill nor by a dedicated specification skill">
+        Read those files of the **SpecBook SCHEMA Model** in
+        <schema-files/> via the `Read` tool to learn the allowed object
+        kinds, properties, nestings, and value constraints. Do not
+        output anything.
         </if>
         <else>
-        Do *not* read <schema-file/> again -- its content is already
-        active in the context. Do not output anything.
+        Do *not* read the files of <schema-files/> again -- their content
+        is already active in the context. Do not output anything.
         </else>
 
 4.  **Activate Artifacts:**
@@ -98,7 +100,7 @@ an ad-hoc change, and it *never* touches the artifact kinds `CODE`,
     <template>
     <ase-tpl-boxed title="SPEC" subtitle="ACTIVATED">
 
-    **SCHEMA**: `<schema-file/>` (<schema-kind/>)
+    **SCHEMA**: <schema-files/> (one `<file/>` (`standard`|`custom`) entry per line, aligned)
     **SPEC**:   `<ase-spec-basedir/>` (<artifact-count/> artifacts)
 
     </ase-tpl-boxed>

package/plugin/skills/ase-spec-activate/help.md

@@ -14,12 +14,13 @@
 The `ase-spec-activate` skill activates the know-how about the
 *SpecBook*-based specification (`SPEC`) of the project in the current
 session: it loads the *SpecBook* format contract, reads the *SpecBook*
-schema configuration of the project (the standard schema bundled with
-*ASE*, or the custom schema configured via `project.artifact.spec.schema`),
-and resolves the list of `SPEC` artifacts in the configured specification
-base directory. The activation is reported in a `SPEC ACTIVATED` box,
-listing the schema file (marked `standard` or `custom`) and the base
-directory with the number of resolved artifacts.
+schema configuration of the project (the schema files configured via
+`project.artifact.spec.schema`, where the entry `std` -- also the default
+-- names the standard schema bundled with *ASE*), and resolves the list
+of `SPEC` artifacts in the configured specification base directory. The
+activation is reported in a `SPEC ACTIVATED` box, listing the schema
+files (each marked `standard` or `custom`) and the base directory with
+the number of resolved artifacts.
 
 Once activated, the specification can be worked with *ad-hoc* in plain
 conversation for the remainder of the session: reading, querying, and