@rse/ase 0.9.36 → 0.9.38

package/dst/ase-hook.js

@@ -250,6 +250,11 @@ export default class HookCommand {
         const val = cfg.get("agent.persona");
         if (typeof val === "string")
             persona = val;
+        /*  determine project boxing transparency  */
+        let boxing = process.env.ASE_PROJECT_BOXING ?? "white";
+        const valBoxing = cfg.get("project.boxing");
+        if (typeof valBoxing === "string")
+            boxing = valBoxing;
         /*  determine headless mode  */
         const headless = (process.env.ASE_HEADLESS ?? "false") === "true" ? "true" : "false";
         /*  provide ASE information to Anthropic Claude Code CLI shell commands
@@ -260,6 +265,7 @@ export default class HookCommand {
                 `export ASE_PLUGIN_ROOT=${quote([pluginRoot])}\n` +
                 `export ASE_USER_ID=${quote([userId])}\n` +
                 `export ASE_PROJECT_ID=${quote([projectId])}\n` +
+                `export ASE_PROJECT_BOXING=${quote([boxing])}\n` +
                 `export ASE_TASK_ID=${quote([taskId])}\n` +
                 `export ASE_SESSION_ID=${quote([sessionId])}\n` +
                 `export ASE_HEADLESS=${quote([headless])}\n` +
@@ -274,6 +280,7 @@ export default class HookCommand {
                 `<ase-persona-style>${persona}</ase-persona-style>\n` +
                 `<ase-user-id>${userId}</ase-user-id>\n` +
                 `<ase-project-id>${projectId}</ase-project-id>\n` +
+                `<ase-project-boxing>${boxing}</ase-project-boxing>\n` +
                 `<ase-task-id>${taskId}</ase-task-id>\n` +
                 `<ase-session-id>${sessionId}</ase-session-id>\n` +
                 `<ase-headless>${headless}</ase-headless>\n` +
@@ -289,7 +296,7 @@ export default class HookCommand {
         const banner = `\n⧉ ASE: ⎈ version: ${versionCurrentPlugin}${versionHint !== "" ? " " + versionHint.replaceAll(/\*/g, "") : ""}` +
             `\n⧉ ASE: ※ user: ${userId}, ⚑ project: ${projectId}` +
             `\n⧉ ASE: ◉ task: ${taskId}, ⏻ session: ${sessionId}` +
-            `\n⧉ ASE: ☯ persona: ${persona}`;
+            `\n⧉ ASE: ☯ persona: ${persona}, ▢ boxing: ${boxing}`;
         /*  inject markdown into session context.
             Anthropic Claude Code CLI and OpenAI Codex CLI expect the context nested in
             "hookSpecificOutput"; GitHub Copilot CLI expects a flat top-level

package/dst/ase-setup.js

@@ -4,6 +4,7 @@
 **  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
 */
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { execa } from "execa";
@@ -11,6 +12,9 @@ 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";
 const toolSpecs = {
     "claude": { cli: "claude", label: "Anthropic Claude Code CLI", pInstall: "install", pRemove: "uninstall", pUpdate: "update" },
@@ -567,6 +571,226 @@ export default class SetupCommand {
             }
         }
     ];
+    /*  the default "ase statusline" format lines used when the user does
+        not override them with positional arguments to "activate"  */
+    statuslineFormatDflt = [
+        "<blue>%u</blue> <red>%p</red> <black>%T</black> %s",
+        "%m %e %t",
+        "%P %c"
+    ];
+    /*  resolve the tool settings file for a given installation scope  */
+    statuslineSettingsFile(tool, scope) {
+        if (tool === "copilot") {
+            const home = process.env.COPILOT_HOME ?? "";
+            const base = home !== "" ? home : path.join(os.homedir(), ".copilot");
+            return path.join(base, "settings.json");
+        }
+        else if (scope === "project")
+            return path.join(process.cwd(), ".claude", "settings.json");
+        else if (scope === "local")
+            return path.join(process.cwd(), ".claude", "settings.local.json");
+        else
+            return path.join(os.homedir(), ".claude", "settings.json");
+    }
+    /*  reject the statusline operation for tools without a scriptable
+        statusline mechanism (only the OpenAI Codex CLI lacks one)  */
+    requireStatuslineTool(tool) {
+        if (tool === "codex")
+            throw new Error("statusline configuration is not supported for --tool codex " +
+                `(the ${toolSpecs[tool].label} has no scriptable statusline mechanism)`);
+    }
+    /*  reject a non-default --scope for the GitHub Copilot CLI, which has a
+        single per-user settings file and thus no scope concept  */
+    requireStatuslineScope(tool, scope) {
+        if (tool === "copilot" && scope !== "user")
+            throw new Error("--scope is only supported for --tool claude " +
+                `(the ${toolSpecs[tool].label} has a single per-user settings file)`);
+    }
+    /*  build the "ase statusline ..." command string from the activate
+        options and the effective format lines  */
+    statuslineCommand(opts, format) {
+        const parts = ["ase", "statusline", "-w", String(opts.width), "-m", String(opts.margin)];
+        if (!opts.icons)
+            parts.push("--no-icons");
+        if (!opts.labels)
+            parts.push("--no-labels");
+        const lines = format.length > 0 ? format : this.statuslineFormatDflt;
+        for (const line of lines)
+            parts.push(`'${line.replace(/'/g, "'\\''")}'`);
+        return parts.join(" ");
+    }
+    /*  determine whether an existing "statusLine" value object is owned by us  */
+    statuslineIsOwned(member) {
+        const obj = member.query("/ * [ pos() == 2 ]")[0];
+        if (obj === undefined)
+            return false;
+        for (const m of obj.query("/ member")) {
+            const key = m.query("/ string [ pos() == 1 ]")[0];
+            if (key !== undefined && key.get("value") === "command") {
+                const val = m.query("/ string [ pos() == 2 ]")[0];
+                const cmd = val !== undefined ? String(val.get("value") ?? "") : "";
+                return cmd.startsWith("ase statusline");
+            }
+        }
+        return false;
+    }
+    /*  locate the top-level "statusLine" member node within the root object  */
+    statuslineFindMember(root) {
+        for (const m of root.query("/ member")) {
+            const key = m.query("/ string [ pos() == 1 ]")[0];
+            if (key !== undefined && key.get("value") === "statusLine")
+                return m;
+        }
+        return undefined;
+    }
+    /*  build the "statusLine" member subtree natively inside the target
+        AST, reproducing the exact whitespace tokens json-asty emits for a
+        canonically 4-space-indented settings.json  */
+    statuslineBuildMember(root, command) {
+        const strMember = (key, val, epilog) => {
+            const k = root.create("string").set({ body: JSON.stringify(key), value: key, epilog: ": " });
+            const v = root.create("string").set({ body: JSON.stringify(val), value: val });
+            const m = root.create("member");
+            if (epilog !== undefined)
+                m.set({ epilog });
+            return m.add(k, v);
+        };
+        const numMember = (key, val, epilog) => {
+            const k = root.create("string").set({ body: JSON.stringify(key), value: key, epilog: ": " });
+            const v = root.create("number").set({ body: String(val), value: val });
+            const m = root.create("member");
+            if (epilog !== undefined)
+                m.set({ epilog });
+            return m.add(k, v);
+        };
+        const obj = root.create("object").set({ prolog: "{\n        ", epilog: "\n    }\n" });
+        obj.add(strMember("type", "command", ",\n        "), strMember("command", command, ",\n        "), numMember("padding", 0));
+        const key = root.create("string").set({
+            body: JSON.stringify("statusLine"),
+            value: "statusLine",
+            epilog: ": "
+        });
+        return root.create("member").add(key, obj);
+    }
+    /*  normalize the previous-last member so a following ",\n    " comma reads cleanly  */
+    statuslineMakeNonLast(member) {
+        const val = member.query("/ * [ pos() == 2 ]")[0];
+        if (val !== undefined) {
+            const ep = val.get("epilog");
+            if (typeof ep === "string" && ep.endsWith("\n"))
+                val.set({ epilog: ep.replace(/\n$/, "") });
+        }
+        member.set({ epilog: ",\n    " });
+    }
+    /*  read a settings.json file into a JSON-ASTy AST  */
+    async statuslineReadAst(file) {
+        let text = "";
+        try {
+            text = await fs.readFile(file, "utf8");
+        }
+        catch {
+            /*  missing file: start from an empty object  */
+        }
+        if (text.trim() === "")
+            text = "{}";
+        return JsonAsty.parse(text);
+    }
+    /*  write a JSON-ASTy AST back to a settings.json file  */
+    async statuslineWriteAst(file, root) {
+        await mkdirp(path.dirname(file));
+        const text = JsonAsty.unparse(root);
+        writeFileAtomic.sync(file, text, { encoding: "utf8" });
+    }
+    /*  handler for "ase setup statusline activate"  */
+    async doStatuslineActivate(tool, scope, opts, format) {
+        this.requireStatuslineTool(tool);
+        this.requireStatuslineScope(tool, scope);
+        const file = this.statuslineSettingsFile(tool, scope);
+        const command = this.statuslineCommand(opts, format);
+        const root = await this.statuslineReadAst(file);
+        const existing = this.statuslineFindMember(root);
+        if (existing !== undefined) {
+            /*  preserve a foreign, hand-crafted statusLine: skip and warn  */
+            if (!this.statuslineIsOwned(existing)) {
+                this.log.write("warning", "setup: statusline: activate: a non-ASE \"statusLine\" " +
+                    `is already present in ${file}: preserving it (skipped)`);
+                return 0;
+            }
+            /*  replace the value object in place, preserving its epilog  */
+            const valNew = this.statuslineBuildMember(root, command).query("/ object")[0];
+            const valOld = existing.query("/ * [ pos() == 2 ]")[0];
+            valNew.set({ epilog: valOld.get("epilog") });
+            existing.del(valOld).add(valNew);
+            this.log.write("info", `setup: statusline: activate: updating ASE "statusLine" in ${file}`);
+        }
+        else {
+            /*  insert a fresh statusLine member  */
+            const members = root.query("/ member");
+            const member = this.statuslineBuildMember(root, command);
+            if (members.length === 0) {
+                root.set({ prolog: "{\n    ", epilog: "}\n" });
+                root.add(member);
+            }
+            else {
+                root.set({ epilog: "}\n" });
+                this.statuslineMakeNonLast(members[members.length - 1]);
+                root.add(member);
+            }
+            this.log.write("info", `setup: statusline: activate: adding ASE "statusLine" to ${file}`);
+        }
+        await this.statuslineWriteAst(file, root);
+        return 0;
+    }
+    /*  handler for "ase setup statusline deactivate"  */
+    async doStatuslineDeactivate(tool, scope) {
+        this.requireStatuslineTool(tool);
+        this.requireStatuslineScope(tool, scope);
+        const file = this.statuslineSettingsFile(tool, scope);
+        /*  a missing settings file means nothing to remove  */
+        try {
+            await fs.access(file);
+        }
+        catch {
+            this.log.write("info", `setup: statusline: deactivate: no settings file ${file} (skipped)`);
+            return 0;
+        }
+        /*  read file  */
+        const root = await this.statuslineReadAst(file);
+        const target = this.statuslineFindMember(root);
+        if (target === undefined) {
+            this.log.write("info", `setup: statusline: deactivate: no "statusLine" in ${file} (skipped)`);
+            return 0;
+        }
+        /*  preserve a foreign, hand-crafted statusLine: skip and warn  */
+        if (!this.statuslineIsOwned(target)) {
+            this.log.write("warning", "setup: statusline: deactivate: a non-ASE \"statusLine\" " +
+                `is present in ${file}: preserving it (skipped)`);
+            return 0;
+        }
+        /*  remove the member and repair the whitespace at the seam  */
+        const members = root.query("/ member");
+        const wasLast = members[members.length - 1] === target;
+        root.del(target);
+        if (wasLast) {
+            if (members.length > 1) {
+                /*  promote the new last member: strip its comma epilog and
+                    restore the pre-"}" newline into the root epilog when the
+                    new-last value is a scalar (a container value carries the
+                    newline in its own epilog already)  */
+                const newLast = members[members.length - 2];
+                newLast.set({ epilog: undefined });
+                const val = newLast.query("/ * [ pos() == 2 ]")[0];
+                const ep = val !== undefined ? val.get("epilog") : undefined;
+                if (!(typeof ep === "string" && ep.endsWith("\n")))
+                    root.set({ epilog: "\n}\n" });
+            }
+            else
+                root.set({ epilog: "}\n" });
+        }
+        await this.statuslineWriteAst(file, root);
+        this.log.write("info", `setup: statusline: deactivate: removing ASE "statusLine" from ${file}`);
+        return 0;
+    }
     /*  parse and validate the --tool option  */
     parseTool(value) {
         if (value !== "claude" && value !== "copilot" && value !== "codex")
@@ -683,5 +907,42 @@ export default class SetupCommand {
             .action(async (servers, opts) => {
             process.exit(await this.doMcp("deactivate", this.parseTool(opts.tool), servers ?? "all", this.parseScope(opts.scope)));
         });
+        /*  parser for the non-negative integer "ase setup statusline" options  */
+        const parseNonNeg = (name) => (value) => {
+            const n = Number.parseInt(value, 10);
+            if (!Number.isFinite(n) || n < 0)
+                throw new Error(`invalid --${name} value: "${value}" (expected a non-negative integer)`);
+            return n;
+        };
+        /*  register CLI sub-command "ase setup statusline"  */
+        const statuslineCmd = setupCmd
+            .command("statusline")
+            .description("activate or deactivate the ASE statusline for a tool")
+            .action(() => {
+            statuslineCmd.outputHelp();
+            process.exit(1);
+        });
+        /*  register CLI sub-command "ase setup statusline activate"  */
+        statuslineCmd
+            .command("activate [format...]")
+            .description("activate the ASE statusline (optionally with custom format lines)")
+            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\"; \"codex\" is unsupported)", toolDflt)
+            .option("-s, --scope <scope>", "target scope (\"user\", \"project\", or \"local\")", "user")
+            .option("-w, --width <n>", "force terminal width to <n> characters (0 = auto-detect via /dev/tty)", parseNonNeg("width"), 0)
+            .option("-m, --margin <n>", "reduce maximum used terminal width by <n> characters on each side", parseNonNeg("margin"), 2)
+            .option("--no-icons", "disable icons in placeholder rendering")
+            .option("--no-labels", "disable labels in front of bold values")
+            .action(async (format, opts) => {
+            process.exit(await this.doStatuslineActivate(this.parseTool(opts.tool), this.parseScope(opts.scope), { width: opts.width, margin: opts.margin, icons: opts.icons, labels: opts.labels }, format ?? []));
+        });
+        /*  register CLI sub-command "ase setup statusline deactivate"  */
+        statuslineCmd
+            .command("deactivate")
+            .description("deactivate the ASE statusline")
+            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\"; \"codex\" is unsupported)", toolDflt)
+            .option("-s, --scope <scope>", "target scope (\"user\", \"project\", or \"local\")", "user")
+            .action(async (opts) => {
+            process.exit(await this.doStatuslineDeactivate(this.parseTool(opts.tool), this.parseScope(opts.scope)));
+        });
     }
 }

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.36",
+    "version":                              "0.9.38",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -54,6 +54,7 @@
         "pretty-ms":                        "9.3.0",
         "luxon":                            "3.7.2",
         "@modelcontextprotocol/sdk":        "1.29.0",
+        "json-asty":                        "1.3.2",
         "zod":                              "4.4.3",
         "which":                            "7.0.0",
         "update-notifier":                  "7.3.1",
@@ -65,6 +66,9 @@
         "ofetch":                           "1.5.1",
         "picomatch":                        "4.0.5"
     },
+    "allowScripts": {
+         "es5-ext":                         true
+    },
     "engines": {
         "npm":                              ">=10.0.0",
         "node":                             ">=22.0.0"

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

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

package/plugin/meta/ase-constitution.md

@@ -16,7 +16,7 @@ any skill flow:
 ⧉ **ASE**: ⎈ version: **<ase-version/>** <ase-version-hint/>
 ⧉ **ASE**: ※ user: **<ase-user-id/>**, ⚑ project: **<ase-project-id/>**
 ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⏻ session: **<ase-session-id/>**
-⧉ **ASE**: ☯ persona: **<ase-persona-style/>**
+⧉ **ASE**: ☯ persona: **<ase-persona-style/>**, ▢ boxing: **<ase-project-boxing/>**
 </template>
 
 Prohibitions

package/plugin/meta/ase-dialog.md

@@ -56,12 +56,14 @@ following procedure:
             If this line exists, parse it according to the format `<label/>: <description/>`.
             Set <n/> to <n/> + 1 (increment entry count).
             Set <label-key/> to `<ase-tpl-key digit="<n/>"/>`.
-            Set <label-text/> to `<ase-tpl-pad width="<width/>" text="<label/>:"/>`.
+            Set <label-text/> to `**<label/>:**`.
+            Set <label-pad/> to `<ase-tpl-pad width="<width/>" text="<label/>:"/>` with
+            the leading `<label/>:` text removed, i.e. only the trailing padding spaces.
             Append an entry to <text/>:
 
             <text>
             <text/>
-            <ase-tpl-boxline><label-key/>  ▶  **<label-text/>** <description/></ase-tpl-boxline>
+            <ase-tpl-boxline><label-key/>  ▶  <label-text/><label-pad/> <description/></ase-tpl-boxline>
             </text>
 
             <if condition="<keys/> is empty">

package/plugin/meta/ase-skill.md

@@ -243,9 +243,58 @@ Skill Identification
     steps at the end of a skill beside the explicit outputs via any
     <template/>.
 
+Artifact Boxing Transparency
+----------------------------
+
+-   *IMPORTANT*: The *boxing* of a project (indicated by
+    <ase-project-boxing/> configuration) classifies how *transparent*
+    its *source artifacts* (specification, architecture, source code,
+    documentation, infrastructure, task plan, and other artifacts) are,
+    and thus how *deeply* you *MUST* inspect or produce them and how
+    *much* of their internals you *MUST* surface.
+
+-   *IMPORTANT*: Boxing modulates only the *work depth* (inspection and
+    production thoroughness) and the *output visibility* (surfaced
+    content and findings) of *artifact-touching* skills, per the three
+    lists below. It *MUST* *NOT* alter the *communication style*
+    (governed exclusively by the persona), and it *MUST* *NOT* apply to
+    skills that neither read, critique, nor write any project source
+    artifact.
+
+    -   If <ase-project-boxing/> is `white`:
+        -   Transparency:      *fully*
+        -   Work depth:        inspect *fully*, produce *thoroughly*
+        -   Findings surfaced: *all*
+        -   Internals exposed: *full* (complete diffs, exhaustive rationale)
+
+    -   If <ase-project-boxing/> is `grey`:
+        -   Transparency:      *partially*
+        -   Work depth:        inspect *significant* parts, produce *reasonably*
+        -   Findings surfaced: *essentials*, summarize rest
+        -   Internals exposed: *key* only (essential hunks, condensed rationale), summarize rest
+
+    -   If <ase-project-boxing/> is `black`:
+        -   Transparency:      *none*
+        -   Work depth:        *minimum* work to satisfy the request
+        -   Findings surfaced: *none* (report only the *outcome*)
+        -   Internals exposed: *none* (no diffs, no code, no per-artifact explanation)
+
+-   *IMPORTANT*: Precedence rule: skill's *explicit* `black` branches
+    deterministically skip or suppress and *win* over the implicit decisions
+    above. Where no such branches exist, the decisions above apply.
+
 Template Patterns
 -----------------
 
+-   *IMPORTANT*: In every `<template/>` below you *MUST* reproduce all
+    box-drawing and decorative glyphs *verbatim*, character-for-character,
+    exactly as written. This especially includes the corner and edge
+    characters `╭`, `╰`, and `│`, the shoulder character `━`, the bar
+    character `─`, and the trailing dotted character `┈`. You *MUST* *NOT*
+    substitute visually similar ASCII fallbacks (e.g. `+`, `|`, `-`) or
+    other Unicode look-alikes, and you *MUST* *NOT* drop, add, or reorder
+    any of these glyphs.
+
 -   When `<ase-tpl-head/>` (no title attribute) should be expanded, use:
 
     <template>
@@ -360,3 +409,4 @@ Template Patterns
     clamped to zero so an over-long text never yields a negative count):
 
     <template><text/><ws/></template>
+

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.36",
+    "version":                              "0.9.38",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

package/plugin/skills/ase-arch-analyze/SKILL.md

@@ -121,6 +121,22 @@ interface quality, quality attributes, and architecture governance.
 
 <flow>
 1.  <step id="STEP 1: Investigate Code Base">
+
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so
+    the user does *not* want the architecture inspected or its findings
+    surfaced. *Skip* the entire investigation and reporting: do *not*
+    invoke any `Agent` tool and do *not* read any source, only output
+    the following <template/> and then *SKIP* the remaining steps STEP 2
+    through STEP 4:
+
+    <template>
+    <ase-tpl-bullet-normal/> **ARCHITECTURE ANALYSIS**: *suppressed* (`project.boxing` is `black`)
+    </template>
+
+    </if>
+
     Investigate the code from an *architectural* perspective. If the
     code base is large, you *MUST* use the `Agent` tool (not inline
     work) to create multiple sub-agents to split the investigation

package/plugin/skills/ase-code-analyze/SKILL.md

@@ -54,6 +54,20 @@ problems in *performance* and *efficiency*, or problems in *security*.
 
 2.  <step id="STEP 2: Investigate Code Base">
 
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so
+    the user does *not* want them inspected or their problems surfaced.
+    *Skip* the entire investigation and analysis: do *not* invoke any
+    `Glob` or `Agent` tool and do *not* read any source, only output
+    the following <template/> and then *SKIP* the remaining step STEP 3:
+
+    <template>
+    <ase-tpl-bullet-normal/> **CODE ANALYSIS**: *suppressed* (`project.boxing` is `black`)
+    </template>
+
+    </if>
+
     First, use the following <template/> to give a hint on this step:
 
     <template>
@@ -109,14 +123,19 @@ problems in *performance* and *efficiency*, or problems in *security*.
 
 3.  <step id="STEP 3: Show Results">
 
-    Before reporting, *apply the severity floor* selected via
-    <getopt-option-severity/> (default `LOW`): define the ordinal rank
-    `LOW`=1, `MEDIUM`=2, `HIGH`=3. *Keep* a detected problem if and only
-    if its `severity` field is `ACCEPTED` *or* `rank(severity)` is greater
-    than or equal to `rank(<getopt-option-severity/>)`; *silently drop*
-    all other problems (they are neither reported nor persisted). With
-    the default floor `LOW`, all problems are kept. `ACCEPTED` problems
-    are *never* dropped.
+    Before reporting, determine the *effective severity floor* <floor/>:
+    define the ordinal rank `LOW`=1, `MEDIUM`=2, `HIGH`=3, start from
+    <floor><getopt-option-severity/></floor> (default `LOW`), and - if
+    <ase-project-boxing/> is equal `grey` - raise <floor/> to `MEDIUM`
+    whenever its current rank is below `rank(MEDIUM)` (grey boxing
+    surfaces only *material* findings of severity `MEDIUM` and above).
+
+    Then *apply the effective severity floor* <floor/>: *Keep* a detected
+    problem if and only if its `severity` field is `ACCEPTED` *or*
+    `rank(severity)` is greater than or equal to `rank(<floor/>)`;
+    *silently drop* all other problems (they are neither reported nor
+    persisted). With the default floor `LOW`, all problems are kept.
+    `ACCEPTED` problems are *never* dropped.
 
     Then renumber the surviving problems contiguously as `P<n/>` with
     <n/> = 1, 2, ... in the original ordering. If *all* problems are

package/plugin/skills/ase-code-craft/SKILL.md

@@ -140,8 +140,11 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
     You *MUST* perform the following sub-steps *internally* and *without
     any output* until and including the recommendation decision. Only
     sub-steps 4-6 below are allowed to produce output, and only if
-    <getopt-option-auto/> is equal `false`. If <getopt-option-auto/> is
-    equal `true`, *skip* the reporting sub-steps 4-6 entirely (perform
+    <getopt-option-auto/> is equal `false` *and* <ase-project-boxing/>
+    is *not* equal `black`.
+
+    If <getopt-option-auto/> is equal `true` or <ase-project-boxing/> is
+    equal `black`, *skip* the reporting sub-steps 4-6 entirely (perform
     no output at all) to speed up processing.
 
     1.  *Propose* corresponding *feature approach*, including optionally,
@@ -187,7 +190,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         <ase-tpl-foot title="APPROACHES"/>
         </template>
 
-    7.  <if condition="<getopt-option-auto/> is not equal `true`">
+    7.  <if condition="<getopt-option-auto/> is not equal `true` and <ase-project-boxing/> is not equal `black`">
 
         In the following, you *MUST* *NOT* use your built-in
         <user-dialog-tool/> tool! Instead, you *MUST* just show a

package/plugin/skills/ase-code-explain/SKILL.md

@@ -43,6 +43,23 @@ code and *explain* it in a *brief*, *standardized*, and *concise* way.
     Second, explain *WHY* the code does it (*rationale*).
 
     Keep your explanations *brief* and *concise*.
+
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so the
+    user wants only the *minimal* surface explanation. Output *only* the
+    *WHAT* block (omit the *WHY* block) with the following <template/>:
+
+    <template>
+    <ase-tpl-bullet-normal/> **WHAT** (You should know what):
+    - [...]
+    - [...]
+    - [...]
+    </template>
+
+    </if>
+    <else>
+
     Output the result with the following <template/>:
 
     <template>
@@ -56,9 +73,21 @@ code and *explain* it in a *brief*, *standardized*, and *concise* way.
     - [...]
     - [...]
     </template>
+
+    </else>
     </step>
 
 3.  <step id="STEP 3: ANALOGY and DIAGRAM">
+
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so
+    deeper elaboration is *not* wanted. *Skip* this STEP 3 and the
+    following STEP 4 entirely: do *not* output any ANALOGY, DIAGRAM,
+    CRUXES, or GOTCHAS, and do *not* dispatch any diagram rendering.
+
+    </if>
+
     **Give insights with ANALOGY and DIAGRAM**.
 
     First, give an analogy by comparing the code to something from

package/plugin/skills/ase-code-insight/SKILL.md

@@ -34,6 +34,21 @@ Give *insights* into the project through the source code of <getopt-arguments/>.
 
 <flow>
 1.  <step id="STEP 1: PROJECT ABSTRACT">
+
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so the
+    user does *not* want them inspected or their internals surfaced.
+    *Skip* the entire insight gathering: do *not* read any source, only
+    output the following <template/> and then *SKIP* the remaining steps
+    STEP 2 through STEP 4:
+
+    <template>
+    <ase-tpl-bullet-normal/> **PROJECT INSIGHT**: *suppressed* (`project.boxing` is `black`)
+    </template>
+
+    </if>
+
     Determine an <abstract/> summary of this project.
     For this, check a potentially existing `README.*` file
     or scan the source files and figure it out indirectly.

package/plugin/skills/ase-code-lint/SKILL.md

@@ -33,6 +33,21 @@ related to a set of code quality aspects.
 
 1.  <step id="STEP 1: Investigation">
 
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so
+    the user does *not* want them inspected or their problems surfaced.
+    *Skip* the entire investigation and reporting: do *not* invoke any
+    `Glob` or `Agent` tool and do *not* read any source, only output
+    the following <template/> and then *SKIP* the remaining steps STEP 2
+    and STEP 3:
+
+    <template>
+    <ase-tpl-bullet-normal/> **LINT**: *suppressed* (`project.boxing` is `black`)
+    </template>
+
+    </if>
+
     First, use the following <template/> to give a hint on this step:
 
     <template>
@@ -76,13 +91,18 @@ related to a set of code quality aspects.
     sort the list by `file` and then numerically by `line`, and set
     <problems/> to that list.
 
-    Then *apply the severity floor* selected via <getopt-option-severity/>
-    (default `LOW`): define the ordinal rank `LOW`=1, `MEDIUM`=2,
-    `HIGH`=3. *Keep* a problem in <problems/> if and only if its
-    `severity` field is `ACCEPTED` *or* `rank(severity)` is greater than
-    or equal to `rank(<getopt-option-severity/>)`; *silently drop* all
-    other problems. With the default floor `LOW`, all problems are kept.
-    `ACCEPTED` problems are *never* dropped.
+    Then determine the *effective severity floor* <floor/>: define the
+    ordinal rank `LOW`=1, `MEDIUM`=2, `HIGH`=3, start from
+    <floor><getopt-option-severity/></floor> (default `LOW`), and - if
+    <ase-project-boxing/> is equal `grey` - raise <floor/> to `MEDIUM`
+    whenever its current rank is below `rank(MEDIUM)` (grey boxing
+    surfaces only *material* findings of severity `MEDIUM` and above).
+
+    Then *apply the effective severity floor* <floor/>: *Keep* a problem
+    in <problems/> if and only if its `severity` field is `ACCEPTED` *or*
+    `rank(severity)` is greater than or equal to `rank(<floor/>)`;
+    *silently drop* all other problems. With the default floor `LOW`, all
+    problems are kept. `ACCEPTED` problems are *never* dropped.
 
     You *MUST* *NOT* output anything else in this step 1.
 
@@ -145,6 +165,7 @@ related to a set of code quality aspects.
 
         2.  Set <context></context> (set to empty).
             Set <diff></diff> (set to empty).
+            Set <diff-condensed></diff-condensed> (set to empty).
 
         3.  Iterate over the change set:
 
@@ -153,7 +174,9 @@ related to a set of code quality aspects.
             1.  Set <file/>         to the `file`         field of <item/>.
                 Set <change-hunks/> to the `change-hunks` field of <item/>.
 
-                Set <diff-file/> to the following <template/>:
+                Unless <ase-project-boxing/> is equal `grey` (where the
+                full unified diff is suppressed and this per-file header is
+                unused), set <diff-file/> to the following <template/>:
 
                 <template>
                 --- <file/> (original)
@@ -170,11 +193,18 @@ related to a set of code quality aspects.
                     Set <new-text/>       to the `new_text`       field of <item/>.
                     Set <context-after/>  to the `context_after`  field of <item/>.
 
-                2.  Determine the hunk *body* as an ordered list of lines,
-                    each carrying a one-character prefix (` ` for context,
-                    `-` for old-side, `+` for new-side). Build it by
-                    concatenating, in order and *skipping any part that is
-                    empty*:
+                2.  *Skip* this substep entirely when <ase-project-boxing/>
+                    is equal `grey` - the full unified diff is suppressed
+                    there, so none of the <hunk-body/>, <old-count/>,
+                    <new-count/>, <old-start/>, or <new-start/> values
+                    below are consumed (substep 4 builds only the condensed
+                    one-liner instead).
+
+                    Otherwise, determine the hunk *body* as an ordered list
+                    of lines, each carrying a one-character prefix (` ` for
+                    context, `-` for old-side, `+` for new-side). Build it
+                    by concatenating, in order and *skipping any part that
+                    is empty*:
 
                     - one ` `-prefixed line for *each* line of
                       <context-before/> (if non-empty),
@@ -217,7 +247,27 @@ related to a set of code quality aspects.
 
                     <template>`<file/>`:<line/></template>
 
-                4.  Append the following <template/> to <diff-file/>,
+                4.  <if condition="<ase-project-boxing/> is equal `grey`">
+
+                    The full unified diff is *suppressed* under grey boxing
+                    (see substep 5 below), so *skip* the full-diff append
+                    and instead build only a *condensed* one-line
+                    representation of this hunk: determine <old-snippet/>
+                    as the *single-line* collapse of <old-text/> (join its
+                    lines with ` ⏎ `, or `∅` when <old-text/> is empty for
+                    a pure insertion) and <new-snippet/> as the same
+                    collapse of <new-text/> (or `∅` when empty for a pure
+                    deletion). Then append the following <template/> to
+                    <diff-condensed/> as a new line:
+
+                    <template>
+                    <ase-tpl-bullet-signal/> `<file/>`:<line/>: `<old-snippet/>` → `<new-snippet/>`
+                    </template>
+
+                    </if>
+                    <else>
+
+                    Append the following <template/> to <diff-file/>,
                     emitting <hunk-body/> verbatim (one already-prefixed
                     line per line, with no extra blank or space-only lines):
 
@@ -226,9 +276,12 @@ related to a set of code quality aspects.
                     <hunk-body/>
                     </template>
 
+                    </else>
+
                 </for>
 
-            3.  Append <diff-file/> to <diff/>.
+            3.  Unless <ase-project-boxing/> is equal `grey` (where
+                <diff-file/> is unused), append <diff-file/> to <diff/>.
 
             </for>
 
@@ -241,7 +294,25 @@ related to a set of code quality aspects.
 
             </template>
 
-        5.  <if condition="<getopt-option-auto/> is not 'true'">
+        5.  <if condition="<getopt-option-auto/> is not 'true' and <ase-project-boxing/> is not equal `black`">
+
+            <if condition="<ase-project-boxing/> is equal `grey`">
+
+            The project source artifacts are classified as a *grey box*, so
+            the user does *not* want the full artifact internals surfaced:
+            *suppress* the full unified diff and instead show only the
+            *condensed* one-line-per-hunk representation. Report the
+            solution with the following <template/>:
+
+            <template>
+            <ase-tpl-bullet-normal/> **<aspect/> SOLUTION**:
+
+            <diff-condensed/>
+
+            </template>
+
+            </if>
+            <else>
 
             Report the solution with the following <template/>:
 
@@ -254,6 +325,8 @@ related to a set of code quality aspects.
 
             </template>
 
+            </else>
+
             </if>
             <else>
 

package/plugin/skills/ase-code-refactor/SKILL.md

@@ -140,8 +140,11 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
     You *MUST* perform the following sub-steps *internally* and *without
     any output* until and including the recommendation decision. Only
     sub-steps 4-6 below are allowed to produce output, and only if
-    <getopt-option-auto/> is equal `false`. If <getopt-option-auto/> is
-    equal `true`, *skip* the reporting sub-steps 4-6 entirely (perform
+    <getopt-option-auto/> is equal `false` *and* <ase-project-boxing/>
+    is *not* equal `black`.
+
+    If <getopt-option-auto/> is equal `true` or <ase-project-boxing/> is
+    equal `black`, *skip* the reporting sub-steps 4-6 entirely (perform
     no output at all) to speed up processing.
 
     1.  *Propose* corresponding *refactoring approach*, including
@@ -187,7 +190,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         <ase-tpl-foot title="APPROACHES"/>
         </template>
 
-    7.  <if condition="<getopt-option-auto/> is not `true`">
+    7.  <if condition="<getopt-option-auto/> is not equal `true` and <ase-project-boxing/> is not equal `black`">
 
         In the following, you *MUST* *NOT* use your built-in
         <user-dialog-tool/> tool! Instead, you *MUST* just show a

package/plugin/skills/ase-code-resolve/SKILL.md

@@ -194,8 +194,11 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
     You *MUST* perform the following sub-steps *internally* and *without
     any output* until and including the recommendation decision. Only
     sub-steps 4-6 below are allowed to produce output, and only if
-    <getopt-option-auto/> is equal `false`. If <getopt-option-auto/> is
-    equal `true`, *skip* the reporting sub-steps 4-6 entirely (perform
+    <getopt-option-auto/> is equal `false` *and* <ase-project-boxing/>
+    is *not* equal `black`.
+
+    If <getopt-option-auto/> is equal `true` or <ase-project-boxing/> is
+    equal `black`, *skip* the reporting sub-steps 4-6 entirely (perform
     no output at all) to speed up processing.
 
     1.  *Propose* corresponding *resolution approach*, including optionally,
@@ -241,7 +244,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         <ase-tpl-foot title="APPROACHES"/>
         </template>
 
-    7.  <if condition="<getopt-option-auto/> is not `true`">
+    7.  <if condition="<getopt-option-auto/> is not equal `true` and <ase-project-boxing/> is not equal `black`">
 
         In the following, you *MUST* *NOT* use your built-in
         <user-dialog-tool/> tool! Instead, you *MUST* just show a

package/plugin/skills/ase-docs-proofread/SKILL.md

@@ -33,6 +33,21 @@ Analyze documents for spelling, punctuation, or grammar errors
 
 1.  <step id="STEP 1: Investigation">
 
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so
+    the user does *not* want them inspected or their problems surfaced.
+    *Skip* the entire investigation and reporting: do *not* invoke any
+    `Glob` or `Agent` tool and do *not* read any document, only output
+    the following <template/> and then *SKIP* the remaining steps STEP 2
+    and STEP 3:
+
+    <template>
+    <ase-tpl-bullet-normal/> **PROOFREAD**: *suppressed* (`project.boxing` is `black`)
+    </template>
+
+    </if>
+
     First, use the following <template/> to give a hint on this step:
 
     <template>
@@ -141,7 +156,26 @@ Analyze documents for spelling, punctuation, or grammar errors
             <description/>
             </template>
 
-        3.  <if condition="<getopt-option-auto/> is not 'true'">
+        3.  <if condition="<getopt-option-auto/> is not 'true' and <ase-project-boxing/> is equal `grey`">
+
+            The project source artifacts are classified as a *grey box*, so
+            the user does *not* want the full artifact internals surfaced:
+            *suppress* the full unified diff and instead show only a
+            *condensed* one-line representation. Determine <old-snippet/>
+            as the *single-line* collapse of <old-text/> (join its lines
+            with ` ⏎ `, or `∅` when <old-text/> is empty for a pure
+            insertion) and <new-snippet/> as the same collapse of
+            <new-text/> (or `∅` when empty for a pure deletion). Then
+            report the correction with the following <template/>:
+
+            <template>
+
+            <ase-tpl-bullet-normal/> **<type/> CORRECTION**: `<old-snippet/>` → `<new-snippet/>`
+
+            </template>
+
+            </if>
+            <elseif condition="<getopt-option-auto/> is not 'true'">
 
             Determine the hunk *body* as an ordered list of lines, each
             carrying a one-character prefix (` ` for context, `-` for
@@ -195,7 +229,7 @@ Analyze documents for spelling, punctuation, or grammar errors
 
             </template>
 
-            </if>
+            </elseif>
 
         4.  <if condition="<getopt-option-auto/> is not 'true'">
 

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

@@ -38,9 +38,12 @@ Format
 The *ChangeLog* file is a Markdown formatted file named `CHANGELOG.md`,
 and contains sections with headers in the style `N.M.K (YYYY-MM-DD)`.
 
-Each *ChangeLog* entry is always formatted as `<prefix/>: <summary/>`
-where the <prefix/> is one of the following tags and their usual related
-changes:
+Each *ChangeLog* entry is always formatted as...
+
+    `<change-type/> [<artifact-kind/>]: <summary/>`
+
+...where the <change-type/> is one of the following tags and their usual
+related changes:
 
     -   `FEATURE`:     new        functionality or configuration
     -   `IMPROVEMENT`: improved   functionality or configuration
@@ -49,9 +52,21 @@ changes:
     -   `CLEANUP`:     cleaned up functionality or configuration
     -   `REFACTOR`:    refactored functionality or configuration
 
+The <artifact-kind/> is one or more of the following *artifact* tags,
+classifying which kind of artifact the change primarily touches. If
+multiple artifact kinds apply, comma-separate them
+(e.g. `[arch, code]`):
+
+    -   `spec`:  requirement/specification artifacts
+    -   `arch`:  architecture/design artifacts
+    -   `code`:  source code artifacts
+    -   `docs`:  documentation artifacts
+    -   `infr`:  infrastructure/build/tooling artifacts
+    -   `othr`:  any other artifacts
+
 The <summary/> is not longer than about 60-80 characters. The
 *ChangeLog* entries for a single product release version are also always
-grouped and sorted according to the above <prefix/> list.
+grouped and sorted according to the above <change-type/> list.
 
 Processing
 ----------
@@ -123,6 +138,16 @@ Processing
     For each Git commit, reduce the Git commit messages to a single
     short <summary/> sentence, not longer than 60-80 characters.
 
+    For each entry, also determine the <artifact-kind/> *artifact kind*
+    tag(s) from the paths of the changed files. To classify a changed
+    file to its artifact class, call the `ase_artifact_list(kind: [
+    ... ])` tool of the `ase` MCP server *once*, passing the `kind`
+    tokens (`spec`, `arch`, `code`, `docs`, `infr`, `othr`), and read
+    the returned `artifacts` array of `{ kind, files }` objects to match
+    each changed file to its kind. Map the matched lower-cased kind back
+    to its upper-cased <artifact-kind/> tag, and comma-separate multiple
+    tags when more than one artifact class applies.
+
     If a <summary/> is too short or especially is not comprehensible
     enough because of too little context information, add some essential
     context, especially references to the class/module/package, etc.
@@ -144,11 +169,11 @@ Processing
     Without immediately modifying the `CHANGELOG.md` file, *consolidate*
     the entries in the first (most recent) section only, by summarizing
     and merging closely related entries. Perform the entry consolidation
-    per <prefix/> group only.
+    per <change-type/> group only.
 
     Without immediately modifying the `CHANGELOG.md` file, *sort* the
     entries in the first (most recent) section only. Instead of the
-    chronological commit order, group the entries by the <prefix/>es.
+    chronological commit order, group the entries by the <change-type/>s.
 
     </step>
 

package/plugin/skills/ase-meta-changelog/help.md

@@ -15,10 +15,13 @@ The `ase-meta-changelog` skill helps to *complete*, *consolidate*, and
 file, based on the underlying *Git* commits and the currently staged
 changes in the Git *index*.
 
-Each entry is formatted as `<prefix>: <summary>` where *prefix* is
-one of `FEATURE`, `IMPROVEMENT`, `BUGFIX`, `UPDATE`, `CLEANUP`, or
-`REFACTOR`. Entries are grouped and sorted by this prefix. The
-date in the section header is also updated to the current date.
+Each entry is formatted as `<change-type> [<artifact-kind>]: <summary>`
+where *change-type* is one of `FEATURE`, `IMPROVEMENT`, `BUGFIX`,
+`UPDATE`, `CLEANUP`, or `REFACTOR`, and *artifact-kind* is one or more
+comma-separated *artifact class* tags out of `spec`, `arch`, `code`,
+`docs`, `infr`, or `othr`. Entries are grouped and sorted by this
+prefix. The date in the section header is also updated to the current
+date.
 
 ##  EXAMPLES
 

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

@@ -123,10 +123,28 @@ Procedure
             *not* output any further explanation.
         </if>
 
+    4.  <if condition="
+            <ase-project-boxing/> is equal `black` and
+            (<getopt-option-coherence/> is equal `true` or
+             <getopt-option-risk/> is equal `true` or
+             <getopt-option-blast/> is equal `true`)
+        ">
+        The project source artifacts are classified as a *black box*, so
+        the user does *not* want the staged changes scrutinized or their
+        coherence, risk, and blast-radius findings surfaced. The
+        requested scrutiny of STEP 3 through STEP 5 is therefore
+        suppressed: only output the following <template/> and then *SKIP*
+        the remaining steps STEP 3 through STEP 5:
+
+        <template>
+        <ase-tpl-bullet-normal/> **DIFF SCRUTINY**: *suppressed* (`project.boxing` is `black`)
+        </template>
+        </if>
+
     </step>
 
 3.  <step id="STEP 3: Assess Intent Coherence"
-        condition="<getopt-option-coherence/> is equal `true` and <diff/> is NOT empty">
+        condition="<getopt-option-coherence/> is equal `true` and <diff/> is NOT empty and <ase-project-boxing/> is not equal `black`">
 
     1.  From the *same* captured <diff/> and <stat/>, *reconstruct the
         single intended change* as a thesis - the one logical, coherent purpose
@@ -203,7 +221,7 @@ Procedure
     </step>
 
 4.  <step id="STEP 4: Score Against Risk Rubric"
-        condition="<getopt-option-risk/> is equal `true` and <diff/> is NOT empty">
+        condition="<getopt-option-risk/> is equal `true` and <diff/> is NOT empty and <ase-project-boxing/> is not equal `black`">
 
     1.  Score the *same* captured <diff/> and <stat/> information
         against the four-axis rubric below. Each axis is scored on an
@@ -275,7 +293,7 @@ Procedure
     </step>
 
 5.  <step id="STEP 5: Render Blast-Radius Map"
-        condition="<getopt-option-blast/> is equal `true` and <diff/> is NOT empty">
+        condition="<getopt-option-blast/> is equal `true` and <diff/> is NOT empty and <ase-project-boxing/> is not equal `black`">
 
     1.  From the *same* captured <diff/> and <stat/>, *extract the
         touched modules* - the distinct changed source files (or their

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

@@ -67,6 +67,19 @@ Procedure
 
 2.  <step id="STEP 2: Review Investigation">
 
+    <if condition="<ase-project-boxing/> is equal `black`">
+
+    The project source artifacts are classified as a *black box*, so
+    the user does *not* want the staged changes scrutinized or their
+    findings surfaced. *Skip* the entire review investigation: do
+    *not* invoke the `Agent` tool and do *not* read any change, set
+    <findings/> to the *empty* list, set <verdict/> to `SKIPPED (boxing:
+    black)`, set <summary/> to a *one-line* neutral restatement of the
+    change intent derived solely from STEP 1, and proceed *directly* to
+    STEP 3.
+
+    </if>
+
     First, use the following <template/> to give a hint on this step:
 
     <template>
@@ -102,13 +115,20 @@ Procedure
     severity floor below, so the floor only affects which findings are
     *rendered*, never the verdict.
 
-    Then *apply the severity floor* selected via <getopt-option-severity/>
-    (default `LOW`): define the ordinal rank `LOW`=1, `MEDIUM`=2,
-    `HIGH`=3. *Keep* a finding in <findings/> if and only if its
-    `severity` field is `ACCEPTED` *or* `rank(severity)` is greater than
-    or equal to `rank(<getopt-option-severity/>)`; *silently drop* all
-    other findings. With the default floor `LOW`, all findings are kept.
-    `ACCEPTED` findings are *never* dropped.
+    Then determine the *effective severity floor* <floor/>: define the
+    ordinal rank `LOW`=1, `MEDIUM`=2, `HIGH`=3, start from
+    <floor><getopt-option-severity/></floor> (default `LOW`), and - if
+    <ase-project-boxing/> is equal `grey` - raise <floor/> to `MEDIUM`
+    whenever its current rank is below `rank(MEDIUM)` (grey boxing
+    surfaces only *material* findings of severity `MEDIUM` and above).
+    The floor affects only which findings are *rendered*, never the
+    <verdict/> derived above.
+
+    Then *apply the effective severity floor* <floor/>: *Keep* a finding
+    in <findings/> if and only if its `severity` field is `ACCEPTED` *or*
+    `rank(severity)` is greater than or equal to `rank(<floor/>)`;
+    *silently drop* all other findings. With the default floor `LOW`, all
+    findings are kept. `ACCEPTED` findings are *never* dropped.
 
     You *MUST* *NOT* output anything else in this STEP 2.