@rse/ase 2.0.5 → 2.0.7

package/plugin/mods/ase-mods-evaluate.ts

@@ -0,0 +1,227 @@
+/*
+**  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>
+*/
+
+/*  Claude Code function hooks module ("mod", EARLY ACCESS):
+    Decision matrix, redrawing the weighted decision matrices of the
+    "ase-meta-evaluate" skill as a grid and rendering in blue and bold the
+    column of the best alternative (resp. of all tied best ones). Its
+    header cells are clickable and sort the criteria rows by their column
+    (cycling the primary, the reverse, and the original order), while the
+    rating row stays the last one.  */
+
+import type { Elements, Frozen, MatchedEvent, RenderElement } from "claude-code"
+import { type Engine, type Char, ROW, RULE, cells, strip, style, width, wrap, split, paint } from "./ase-mods-common.ts"
+
+/*  the marker line above a decision matrix  */
+const MARKER = /\*{0,2}EVALUATION\*{0,2}:\s+\*{0,2}Weighted Multi-Criteria Decision Matrix/
+
+/*  the color of the best alternatives, and the rating distance (relative to
+    the best rating) below which alternatives tie (as in "ase-meta-evaluate")  */
+const WINNER = "blue"
+const TIE    = 0.01
+
+/*  the sort marks of the orders (each taking the same columns)  */
+const MARK = { desc: " ▼", asc: " ▲", none: "  " } as const
+
+/*  the indent of the wrapped lines of a criterion, the narrowest criteria
+    column, and the size limit of a single "Markdown" element  */
+const INDENT = 2
+const NARROW = 12
+const LIMIT  = 10000
+
+/*  a decision matrix with the Markdown text before and after it: its header
+    cells, its criteria rows (with the values of their weight and evaluations),
+    its rating row, and the columns of the best alternatives  */
+type Matrix = {
+    before:  string,
+    after:   string,
+    header:  string[],
+    rows:    { cells: string[], values: number[] }[],
+    rating:  string[],
+    winners: Set<number>
+}
+
+/*  the sort of a matrix: the sorted column and its order  */
+type Order = "desc" | "asc"
+type Sort  = { column: number, order: Order }
+
+/*  read the number of a cell (without bold markup and a leading plus sign)  */
+const number = (cell: string): number => {
+    const text = cell.replace(/\*/g, "").trim().replace(/^\+/, "")
+    return text !== "" ? Number(text) : NaN
+}
+
+/*  parse the decision matrix out of the text of a reply  */
+const parse = (text: string): Matrix | undefined => {
+    const lines = text.split("\n")
+    const m = lines.findIndex((line) => MARKER.test(line))
+    const h = lines.findIndex((line, i) => m !== -1 && i > m && ROW.test(line))
+    if (h === -1 || !RULE.test(lines[h + 1] ?? ""))
+        return undefined
+    const header = cells(lines[h]!).map((cell) => cell.replace(/\*/g, ""))
+    if (header.length < 3 || !/Criteria/.test(header[0]!) || !/Weight/.test(header[1]!))
+        return undefined
+    let end = h + 2
+    while (end < lines.length && ROW.test(lines[end]!))
+        end++
+    const rows   = lines.slice(h + 2, end).map((line) => cells(line))
+    const rating = rows.pop() ?? []
+    if (rows.length === 0 || rows.some((row) => row.length !== header.length)
+        || rating.length !== header.length || rating[0]!.replace(/\*/g, "") !== "RATING")
+        return undefined
+    const values  = rows.map((row) => row.slice(1).map(number))
+    const ratings = rating.slice(2).map(number)
+    if ([ ...values.flat(), ...ratings ].some((value) => !Number.isFinite(value)))
+        return undefined
+    const best = Math.max(...ratings)
+    return {
+        before:  lines.slice(0, h).join("\n").trim(),
+        after:   lines.slice(end).join("\n").replace(/^\n+/, "").trimEnd(),
+        header,
+        rows:    rows.map((row, k) => ({ cells: row, values: values[k]! })),
+        rating,
+        winners: new Set(ratings.flatMap((value, j) =>
+            value === best || best - value < TIE * Math.abs(best) ? [ j + 2 ] : []))
+    }
+}
+
+/*  advance the sort by a clicked column: its primary order (ascending for
+    the criteria names, descending for the values), then its reverse order,
+    and then the original order again  */
+const advance = (sort: Sort | undefined, column: number): Sort | undefined => {
+    const primary: Order = column === 0 ? "asc"  : "desc"
+    const reverse: Order = column === 0 ? "desc" : "asc"
+    if (sort?.column !== column)
+        return { column, order: primary }
+    return sort.order === primary ? { column, order: reverse } : undefined
+}
+
+/*  order the criteria rows by the sort (stable, so equal rows keep their original order)  */
+const order = (rows: Matrix["rows"], sort: Sort | undefined): Matrix["rows"] => {
+    if (sort === undefined)
+        return rows
+    const sign = sort.order === "asc" ? 1 : -1
+    return [ ...rows ].sort((a, b) => sign * (sort.column === 0 ?
+        strip(a.cells[0]!).localeCompare(strip(b.cells[0]!)) :
+        a.values[sort.column - 1]! - b.values[sort.column - 1]!))
+}
+
+/*  the decision matrix: its state and its operations  */
+export const modEvaluate = () => {
+    /*  the last known width of the terminal and the sorts of the matrices  */
+    let columns = 80
+    const sorts = new Map<string, Sort>()
+
+    /*  sort the criteria rows of a matrix by a clicked header cell and redraw it  */
+    const press = (engine: Pick<Engine, "invalidate">, request: string, column: number) => () => {
+        const sort = advance(sorts.get(request), column)
+        if (sort !== undefined)
+            sorts.set(request, sort)
+        else
+            sorts.delete(request)
+        engine.invalidate()
+    }
+
+    /*  redraw a reply which contains a decision matrix (terminal only),
+        resp. draw nothing for any other reply  */
+    const render = (e: Frozen<MatchedEvent<"ui.render", { component: "AssistantMessage", surface: "terminal" }>>,
+        ui: Elements["terminal"], engine: Pick<Engine, "invalidate">): RenderElement | undefined => {
+        /*  act on decision matrices only  */
+        columns = e.viewport?.columns ?? columns
+        const matrix = parse(e.props.text)
+        if (matrix === undefined || matrix.before.length > LIMIT || matrix.after.length > LIMIT)
+            return undefined
+
+        /*  style the cells: the header ones in bold, the criteria rows in their sort
+            order, and the columns of the best alternatives in blue and bold  */
+        const sort = sorts.get(e.requestId)
+        const tint = (chars: Char[], column: number): Char[] =>
+            matrix.winners.has(column) ? chars.map((char) => ({ ...char, bold: true, color: WINNER })) : chars
+        const head = matrix.header.map((cell, c) => tint(style(`**${cell}**`, undefined), c))
+        const body = [ ...order(matrix.rows, sort).map((row) => row.cells), matrix.rating ]
+            .map((row) => row.map((cell, c) => tint(style(c === 0 ? strip(cell) : cell, undefined), c)))
+
+        /*  determine the column widths: the value columns at their natural width
+            (the header cells with room for the sort mark), the criteria column
+            within the remaining columns (gutter, grid lines, cell paddings, and a
+            spare column subtracted), else leave the matrix to the engine  */
+        const widths = head.map((cell, c) =>
+            Math.max(width(cell) + MARK.none.length, ...body.map((row) => width(row[c]!))))
+        const avail  = columns - 2 - (3 * head.length + 1) - 1 - widths.slice(1).reduce((sum, w) => sum + w, 0)
+        if (avail < Math.max(NARROW, width(head[0]!) + MARK.none.length))
+            return undefined
+        widths[0] = Math.min(widths[0]!, avail)
+
+        /*  resolve the UI elements  */
+        const { Box, Text, Button, Markdown } = ui
+
+        /*  pad the parts of a cell line of the given width to its column width:
+            left-aligned for the criteria, right-aligned for the values  */
+        const align = <T>(c: number, used: number, parts: T[]): (T | string)[] => {
+            const pad = " ".repeat(Math.max(0, widths[c]! - used))
+            return c === 0 ? [ ...parts, pad ] : [ pad, ...parts ]
+        }
+
+        /*  draw a header cell: its styled text inside a hover-scoping box, which while
+            hovered reveals a row of clickable plain buttons (one per styled run, as in
+            the grill table) on top of it, followed by its sort mark  */
+        const heading = (c: number): RenderElement[] => {
+            const group   = `h${c}`
+            const onPress = press(engine, e.requestId, c)
+            const buttons = split(head[c]!).map(({ text, bold }, r) =>
+                Button({ key: `${group}/${r}`, label: text, plain: true, onPress,
+                    hover: { scope: group, inverse: true, bold } }))
+            return align(c, width(head[c]!) + MARK.none.length, [
+                Box({ key: group, hover: { scope: group }, children: [
+                    Text({ children: paint(Text, head[c]!) }),
+                    Box({ position: "absolute", top: 0, left: 0, display: "none",
+                        hover: { scope: group, display: "flex" }, flexDirection: "row", children: buttons })
+                ] }),
+                Text({ children: sort?.column === c ? MARK[sort.order] : MARK.none })
+            ]).map((part) => typeof part === "string" ? Text({ children: part }) : part)
+        }
+
+        /*  draw a line of the grid out of the parts of its cells, resp. a rule  */
+        const draw = (parts: RenderElement[][]) => Box({ flexDirection: "row", children: [
+            Text({ children: "│ " }),
+            ...parts.flatMap((part, c) => c > 0 ? [ Text({ children: " │ " }), ...part ] : part),
+            Text({ children: " │" })
+        ] })
+        const rule = (l: string, m: string, r: string) =>
+            Text({ wrap: "truncate-end", children: l + widths.map((w) => "─".repeat(w + 2)).join(m) + r })
+
+        /*  draw the matrix as a grid: a rule below the header and above the rating
+            row, and the criteria wrapped within their column  */
+        const grid: RenderElement[] = [
+            rule("┌", "┬", "┐"),
+            draw(head.map((_, c) => heading(c))),
+            rule("├", "┼", "┤")
+        ]
+        body.forEach((row, k) => {
+            if (k === body.length - 1)
+                grid.push(rule("├", "┼", "┤"))
+            wrap(row[0]!, widths[0]!, INDENT).forEach((line, i) =>
+                grid.push(draw(row.map((cell, c) => {
+                    const chars = c === 0 ? line : i === 0 ? cell : []
+                    return [ Text({ children: align(c, width(chars), paint(Text, chars)) }) ]
+                }))))
+        })
+        grid.push(rule("└", "┴", "┘"))
+
+        /*  mimic the reply row of the engine: blank row above and bullet gutter  */
+        return Box({ flexDirection: "row", marginTop: 1, width: "100%", children: [
+            Box({ flexShrink: 0, minWidth: 2, children: Text({ children: e.props.isFirstOfReply ? "⏺" : " " }) }),
+            Box({ flexDirection: "column", flexGrow: 1, flexShrink: 1, children: [
+                ...(matrix.before !== "" ? [ Markdown({ text: matrix.before }) ] : []),
+                Box({ flexDirection: "column", marginTop: matrix.before !== "" ? 1 : 0, children: grid }),
+                ...(matrix.after !== "" ? [ Box({ marginTop: 1, children: Markdown({ text: matrix.after }) }) ] : [])
+            ] })
+        ] })
+    }
+
+    return { render }
+}
+

package/plugin/mods/ase-mods-grill.ts

@@ -13,16 +13,12 @@
     "n" or "nX" into the prompt.  */
 
 import type { Elements, Frozen, MatchedEvent, RenderElement } from "claude-code"
-import { type Engine, type Char, PICKED, style, width, wrap, split, paint } from "./ase-mods-common.ts"
+import { type Engine, type Char, PICKED, ROW, RULE, cells, style, width, wrap, split, paint } from "./ase-mods-common.ts"
 
 /*  the marker line above a grilling table (single-round and multi-round,
     optionally labeled with the perspective and/or grounding)  */
 const MARKER = /⧉ \*{0,2}ASE\*{0,2}: GRILLING(?: ROUND \d+\/\d+)?(?: \([^)]*\))?:/
 
-/*  a row and the delimiter row of a Markdown table  */
-const ROW  = /^ *\|.*\| *$/
-const RULE = /^ *\|(?: *:?-+:? *\|)+ *$/
-
 /*  the separator between two answers, the letter of
     an answer, and the number of a question  */
 const ANSWER = /,\s+(?=\*{0,2}[A-Z]\*{0,2}\s+▶)/
@@ -48,31 +44,6 @@ type Table = {
     rows:   { number: number, question: string, answers: { letter: string, text: string }[] }[]
 }
 
-/*  split a Markdown table row into its cells  */
-const cells = (line: string): string[] => {
-    const result: string[] = []
-    const body = line.trim().replace(/^\|/, "").replace(/\|$/, "")
-    let cell = ""
-    let code = false
-    for (let i = 0; i < body.length; i++) {
-        const ch = body[i]!
-        if (ch === "`")
-            code = !code
-        if (!code && ch === "\\" && body[i + 1] === "|") {
-            cell += "|"
-            i++
-        }
-        else if (!code && ch === "|") {
-            result.push(cell.trim())
-            cell = ""
-        }
-        else
-            cell += ch
-    }
-    result.push(cell.trim())
-    return result
-}
-
 /*  parse the grilling table out of the text of a reply  */
 const parse = (text: string): Table | undefined => {
     const lines = text.split("\n")

package/plugin/mods/ase-mods-help-browse.ts

@@ -12,9 +12,10 @@
     where typed text edits the filter, LEFT/RIGHT (or the wheel over the
     skills) selects a skill, UP/DOWN (or the wheel over the manual page)
     scroll its manual page (with the matches of the filter marked), RETURN
-    takes over its command into the prompt, "!!" switches over to the
-    intent help for the filter, and "//" leaves the filter in the prompt
-    (which mirrors the filter while the browser is shown).  */
+    takes over its command into the prompt, SPACE takes it over into the
+    synopsis form, "!!" switches over to the intent help for the filter,
+    and "//" leaves the filter in the prompt (which mirrors the filter while
+    the browser is shown).  */
 
 import type { Elements, Frozen, PromptBox, PromptEditInput, RenderElement } from "claude-code"
 import { type Engine, type Char, type BandRender, type BandScroll, type View, PICKED,
@@ -228,24 +229,26 @@ export const modHelpBrowse = () => {
     const hold = (current: Browse): PromptBox => held(current.filter.trimEnd())
 
     /*  take over the command of the selected manual page into the prompt (closing
-        the browser), if any page matches, and determine the prompt to show  */
-    const take = (current: Browse): PromptBox => {
+        the browser), if any page matches, optionally suffixed with a trigger (to
+        switch over to its band), and determine the prompt to show  */
+    const take = (current: Browse, trigger = ""): PromptBox => {
         const doc = matching(current)[current.select]?.doc
         if (doc === undefined)
             return hold(current)
         reset()
-        const text = `/${doc.skill} `
+        const text = `/${doc.skill} ${trigger}`
         return { text, cursor: text.length }
     }
 
     /*  while the manpage browser is shown, every edit is a key of the browser:
         LEFT/RIGHT select a manual page, UP/DOWN scroll it by a line, RETURN takes
-        over the command of the selected page, "//" (two "/" in a row) closes the
-        browser and leaves the filter in the prompt, "!!" (two "!"
-        in a row, for a non-empty filter) closes the browser with the filter suffixed
-        with the trigger of the intent help (to switch over to it), a deletion (like
-        BACKSPACE) deletes the last character of the filter, and any other typed
-        text is appended to the filter  */
+        over the command of the selected page, SPACE takes it over suffixed with
+        the trigger of the synopsis form, "//" (two "/" in a row) closes the
+        browser and leaves the filter in the prompt, "!!" (two "!" in a row, for
+        a non-empty filter) closes the browser with the filter suffixed with the
+        trigger of the intent help (both to switch over to the other band), a
+        deletion (like BACKSPACE) deletes the last character of the filter, and
+        any other typed text is appended to the filter  */
     const edit = (e: Frozen<PromptEditInput>): PromptBox => {
         const current   = browse!
         const key       = decode(e)
@@ -272,6 +275,8 @@ export const modHelpBrowse = () => {
         current.filter += pending
         if (key.name === "return")
             return take(current)
+        if (key.text === " ")
+            return take(current, "!!")
         if (key.name === "up" || key.name === "down")
             current.scroll = Math.max(0, current.scroll + (key.name === "up" ? -1 : 1))
         else if (key.step !== 0) {
@@ -393,7 +398,7 @@ export const modHelpBrowse = () => {
             status: `[ ${list.length}/${docs?.length ?? 0} manpages ]`,
             hints:  `←/→${wheeled}: select · ` +
                 `${geometry.overflow ? "wheel or CTRL+x + TAB + ↑/↓/PgUp/PgDn" : "↑/↓"}: scroll · ` +
-                "//: cancel+close · ⏎: apply+close" +
+                "//: cancel+close · ⏎: apply+close · SPACE: compose" +
                 (current.filter.trim() !== "" ? " · !!: Find Skill Command" : "") + " · (type for filtering)",
             rows:   (i) => i === 0 ? field : entry(current.top + i - 2),
             rule:   (i) => i === 1,

package/plugin/mods/ase-mods-help-find.ts

@@ -10,9 +10,10 @@
     the skill "ase-help-intent", but over the session context), and showing
     the proposed skills in a master/detail view in the band above the
     prompt, where LEFT/RIGHT (or the wheel over the skills) selects a skill,
-    UP/DOWN and "b"/"f"/SPACE (or the wheel over the details) scroll its
-    details, RETURN picks its command into the prompt, and "!!", BACKSPACE, or
-    any other key restores the prompt as typed without the trigger.  */
+    UP/DOWN and "b"/"f" (or the wheel over the details) scroll its details,
+    RETURN picks its command into the prompt, SPACE picks it into the synopsis
+    form, and "!!", BACKSPACE, or any other key restores the prompt as typed
+    without the trigger.  */
 
 import type { Elements, Frozen, PromptBox, PromptEditInput, RenderElement } from "claude-code"
 import { type Engine, type Char, type BandRender, type BandScroll, type View, PICKED, CODE,
@@ -198,11 +199,13 @@ export const modHelpFind = () => {
 
     /*  while the intent band is shown, every edit is a key of the band (with the
         prompt held): LEFT/RIGHT select a proposal, UP/DOWN scroll its details by
-        a line and "b"/"f"/SPACE by a page (as the engine consumes PAGEUP/PAGEDOWN),
+        a line and "b"/"f" by a page (as the engine consumes PAGEUP/PAGEDOWN),
         RETURN (arriving as a typed newline in the held prompt) operates the band
-        as at the prompt, "//" (two "/" in a row) closes the band with the prompt
-        as typed suffixed with the trigger of the manpage browser (to switch over
-        to it), and "!!" (two "!" in a row), a deletion (like BACKSPACE), or any
+        as at the prompt, SPACE closes the band with the command of the selected
+        proposal suffixed with the trigger of the synopsis form, "//" (two "/"
+        in a row) closes the band with the prompt as typed suffixed with the
+        trigger of the manpage browser (both to switch over to the other band),
+        and "!!" (two "!" in a row), a deletion (like BACKSPACE), or any
         other key closes the band and restores the prompt as typed without the
         trigger (onto whose end the edit of a typed text is still to be applied)  */
     const edit = (e: Frozen<PromptEditInput>): PromptBox | string => {
@@ -222,8 +225,13 @@ export const modHelpFind = () => {
             const text = submit()
             return intent !== undefined ? held(draft) : { text, cursor: text.length }
         }
+        if (state === "done" && key.text === " ") {
+            reset()
+            const text = `${proposals[current.select]!.command} !!`
+            return { text, cursor: text.length }
+        }
         const roll = key.name === "up" ? -1 : key.name === "down" ? 1 :
-            key.text === "b" ? -current.page : key.text === "f" || key.text === " " ? current.page : 0
+            key.text === "b" ? -current.page : key.text === "f" ? current.page : 0
         const step = roll !== 0 ? 0 : key.step
         if (state === "done" && (roll !== 0 || step !== 0)) {
             if (step !== 0) {
@@ -406,7 +414,7 @@ export const modHelpFind = () => {
             (the intent itself stays visible in the prompt)  */
         return panel(ui, geometry, current, {
             title: TITLE,
-            hints: current.state === "done" ? "⌫/!!: cancel+close · ⏎: apply+close · ←/→: select · b/f/SPACE: scroll" +
+            hints: current.state === "done" ? "⌫/!!: cancel+close · ⏎: apply+close · SPACE: compose · ←/→: select · b/f: scroll" +
                 (geometry.overflow ? " · wheel: select/scroll" : "") + " · //: Browse Skill Manpages" :
                 "⌫/!!/any key: cancel+close · //: Browse Skill Manpages",
             rows:  (i) => {

package/plugin/mods/ase-mods-help-hint.ts

@@ -29,7 +29,7 @@ const GROUP  = /\[(?:[^[\]]|\[[^\]]*\])*\]|\((?:[^()]|\([^)]*\))*\)|\S+/g
 const NBSP   = String.fromCodePoint(0xA0)
 const SYNTAX = "gray"
 const REFER  = "red"
-const INDENT = 4
+const INDENT = 2
 const TITLE  = "[ ⧉ ASE: Show Skill Synopsis ]"
 
 /*  a hint band: the scroll state of its frame, the skill command as typed,

package/plugin/mods/ase-mods.ts

@@ -6,8 +6,9 @@
 
 /*  Claude Code function hooks module ("mod", EARLY ACCESS):
     Hooking infrastructure, registering the function hooks and dispatching
-    them into the grill table ("ase-mods-grill.ts"), the intent help
-    ("ase-mods-help-find.ts"), the synopsis form ("ase-mods-help-compose.ts"),
+    them into the grill table ("ase-mods-grill.ts"), the decision matrix
+    ("ase-mods-evaluate.ts"), the intent help ("ase-mods-help-find.ts"),
+    the synopsis form ("ase-mods-help-compose.ts"),
     the manual band ("ase-mods-help-show.ts"), the manpage browser
     ("ase-mods-help-browse.ts"), and the hint band ("ase-mods-help-hint.ts").
     As the engine loads only a module spelling "on", "$", and "next" literally,
@@ -17,6 +18,7 @@
 import type { Register, PromptBox, Timer } from "claude-code"
 import { type Band, TRIGGER } from "./ase-mods-common.ts"
 import { modGrill }           from "./ase-mods-grill.ts"
+import { modEvaluate }        from "./ase-mods-evaluate.ts"
 import { modHelpFind }        from "./ase-mods-help-find.ts"
 import { modHelpCompose }     from "./ase-mods-help-compose.ts"
 import { modHelpShow }        from "./ase-mods-help-show.ts"
@@ -29,14 +31,15 @@ export const register: Register = (on, options) => {
     if (options.enabled === false)
         return
 
-    /*  the grill table, the intent help, the synopsis form, the manual band,
-        the manpage browser, and the hint band  */
-    const grill  = modGrill()
-    const intent = modHelpFind()
-    const skill  = modHelpCompose()
-    const manual = modHelpShow()
-    const browse = modHelpBrowse()
-    const hint   = modHelpHint()
+    /*  the grill table, the decision matrix, the intent help, the synopsis form,
+        the manual band, the manpage browser, and the hint band  */
+    const grill    = modGrill()
+    const evaluate = modEvaluate()
+    const intent   = modHelpFind()
+    const skill    = modHelpCompose()
+    const manual   = modHelpShow()
+    const browse   = modHelpBrowse()
+    const hint     = modHelpHint()
 
     /*  the bands above the prompt (the synopsis form, the intent band, and the
         manpage browser, opened in this order), the shown one (as at most one is
@@ -198,16 +201,19 @@ export const register: Register = (on, options) => {
         next.called || shown() === undefined ? next(e) :
             { drop: "intent band or synopsis form failed" })
 
-    /*  redraw the replies which contain a grilling table (terminal only), where
-        the chain beneath runs, although its drawing is replaced by us (but this
-        at least silences a warning in the debug output of Claude Code)  */
+    /*  redraw the replies which contain a grilling table or a decision matrix
+        (terminal only), where the chain beneath runs, although its drawing is
+        replaced by us (but this at least silences a warning in the debug output
+        of Claude Code)  */
     on("ui.render", { component: "AssistantMessage", surface: "terminal" }, async ($, e, next) => {
-        const drawn = await next(e)
-        return grill.render(e, $.ui.resolve(e), {
-            invalidate: () => $.ui.invalidate("ui.render"),
+        const drawn      = await next(e)
+        const ui         = $.ui.resolve(e)
+        const invalidate = () => $.ui.invalidate("ui.render")
+        return grill.render(e, ui, {
+            invalidate,
             prompt:     () => $.prompt.read(),
             fill:       (text) => $.prompt.fill({ text })
-        }) ?? drawn
+        }) ?? evaluate.render(e, ui, { invalidate }) ?? drawn
     })
 
     /*  draw the intent band resp. the synopsis form, else the manual page,

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

@@ -1,6 +1,6 @@
 ---
 name: ase-code-edit
-argument-hint: "[--help|-h] [--mode|-m auto|craft|refactor|resolve] [--approach|-a] [--grill|-g] [--grill-rounds|-r <n>] [--grill-until|-u MUST|SHOULD|MAY] [--grill-perspective|-p <perspective>] [--grill-ground|-G] [--verify|-v] [--worktree|-w <name>[:<branch>]] [--loop|-l] [<query>|<issue-id>]"
+argument-hint: "[--help|-h] [--mode|-m auto|craft|refactor|resolve] [--approach|-a] [--grill|-g] [--grill-rounds|-r <n>] [--grill-until|-u MUST|SHOULD|MAY] [--grill-perspective|-p <perspective>] [--grill-ground|-G] [--verify|-v light|none|full] [--worktree|-w <name>[:<branch>]] [--loop|-l] [<query>|<issue-id>]"
 description: >
     Edit Source Code: Use when the user wants to "edit" the code base in
     one shot from a query or a bare analyzer issue id like "P1", fusing
@@ -22,7 +22,7 @@ Edit Source Code
 
 <expand name="getopt"
     arg1="ase-code-edit"
-    arg2="--mode|-m=(auto|craft|refactor|resolve) --approach|-a --grill|-g --grill-rounds|-r=1 --grill-until|-u=(MUST|SHOULD|MAY) --grill-perspective|-p= --grill-ground|-G --verify|-v --worktree|-w= --loop|-l">
+    arg2="--mode|-m=(auto|craft|refactor|resolve) --approach|-a --grill|-g --grill-rounds|-r=1 --grill-until|-u=(MUST|SHOULD|MAY) --grill-perspective|-p= --grill-ground|-G --verify|-v=(light|none|full) --worktree|-w= --loop|-l">
     $ARGUMENTS
 </expand>
 
@@ -238,11 +238,18 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
                 arg3="file and directory paths, identifiers, symbols, types, commands, options, configuration keys, and literal values"
                 arg4="the code base"
                 arg5="">
-                <if condition="<getopt-option-verify/> is not equal `true`">
+                <if condition="<getopt-option-verify/> is equal `none`">
                 Raise *no* questions at all of focus area `REGRESSION`
-                or `CONFIRMATION`, as without `--verify` no verification
-                takes place which could honor their decisions.
-                </if></expand>
+                or `CONFIRMATION`, as under `--verify none` no
+                verification takes place which could honor their
+                decisions.
+                </if>
+                <elseif condition="<getopt-option-verify/> is equal `light`">
+                Raise *no* questions at all of focus area
+                `CONFIRMATION`, as under `--verify light` no
+                change-specific tests take place which could honor
+                their decisions.
+                </elseif></expand>
 
             If <grill-stop/> is `true`, skip the remaining items of
             this round and all remaining rounds, and continue with
@@ -388,27 +395,57 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
 
 7.  **State: verifying:**
 
-    Enter this state only if <getopt-option-verify/> is equal `true`.
-    Otherwise you *MUST* *strictly skip* the entire state and *any*
-    verification: do *NOT* run any build, tests, linter, or
-    type-checker, and do *NOT* execute the modified program.
+    Enter this state only if <getopt-option-verify/> is equal `light` or
+    `full`. Otherwise (`none`) you *MUST* *strictly skip* the entire
+    state and *any* verification: do *NOT* run any build, tests, linter,
+    or type-checker, and do *NOT* execute the modified program.
 
     1.  Verify whether the implementation fulfills <todo-what/> and
-        <todo-how/> by running available verification commands
-        (build, tests, linter, type-checker)
+        <todo-how/>
         <if condition="<worktree-dir/> is not empty">
-        , each with <worktree-dir/> as its working directory
-        </if>.
+        , running every command with <worktree-dir/> as its working
+        directory
+        </if>:
+
+        -   Under `light` and `full`: run the available lint and build
+            commands (including the type-checker) and the already
+            existing regression test suite, if any.
+
+        -   Under `full` only: additionally perform *individual*,
+            *change-specific* manual tests, which exercise the changed
+            behavior through ad-hoc scratch tests and program runs.
+            Clean up all scratch test files afterwards, so they never
+            become part of the change set.
 
         If the verification fails, you *MUST* *adjust* the failing parts
-        of the change set and *RE-VERIFY* until the verification passes!
+        of the change set and *RE-VERIFY* -- for at most *ten* rounds
+        in total.
+
+    2.  <if condition="the verification still fails after the last round">
+
+        Only output the following <template/>, listing one bullet line
+        per remaining failure:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-code-edit**, ▶ status: **verification failed**
 
-    2.  Only output the following <template/>:
+        <ase-tpl-bullet-signal/> **REMAINING FAILURES**:
+
+        -   <failure/>
+        [...]
+        </template>
+
+        </if>
+        <else>
+
+        Only output the following <template/>:
 
         <template>
         ⧉ **ASE**: ✪ skill: **ase-code-edit**, ▶ status: **verification passed**
         </template>
 
+        </else>
+
 8.  **Loop or Finish:**
 
     <if condition="<getopt-option-loop/> is equal `true`">