@rse/ase 2.0.6 → 2.0.8

package/plugin/mods/ase-mods-task-edit.ts

@@ -0,0 +1,427 @@
+/*
+**  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):
+    Task band, showing for "ase-task-edit --interactive" (signaled through a tool
+    registered by this mod, whose absence tells the skill that no band exists) the
+    task in the band above the prompt, rendered like the read dialog of the task
+    board TUI, following all changes of the task (keeping the scroll position and
+    showing the last change as a unified diff with line numbers) and scrolled by the
+    wheel, while the prompt stays free for typing. A "##" typed at the end of the
+    prompt drops the diff, showing just the latest state of the task. The band closes
+    once a next step of the skill (like "DONE") is submitted at the prompt.  */
+
+import type { Elements, PromptBox, RenderElement, Timer } from "claude-code"
+import { type Engine, type Char, type BandRender, type BandScroll, type View, PICKED,
+    uniform, width, wrap, layout, wheel, panel } from "./ase-mods-common.ts"
+
+/*  the tool signaling the band, as listed for the model  */
+export const TOOL = {
+    name:        "ase_task_band",
+    description: "Open the band above the prompt, which shows the task `id` and follows its changes, " +
+        "for \"ase-task-edit --interactive\". Returns `OK: ...` or `ERROR: ...` as text.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id:       { type: "string", description: "task identifier" },
+            sections: { type: "string", description: "comma-separated names of the plan sections under focus, " +
+                "or empty to show the entire task" }
+        },
+        required: [ "id" ]
+    }
+}
+
+/*  the next steps of the skill closing the band once submitted, the entity tag
+    at the end of a loaded task (present for an existing task only), the share of
+    the terminal height taken by the band outside fullscreen, the interval of
+    following the task changes, the least digits of the line numbers, the columns of
+    comparing the shown task, and the colors of the rendering (the "dim", "accent", and
+    "signal" roles of the task board TUI, the first also for the line numbers, and the
+    lines and words of the diff, with the codes the diffs of the session end up with, so
+    they look alike under any recoloring, where the accent and the removed lines use
+    the terminal palette, as the engine maps a color name to a fixed color and
+    refuses "ansi:*"), and the changed share of the words up to which they are shown  */
+const CLOSE  = /^(?:DONE|GRILL|DRAFT|IMPLEMENT|CANCEL)$/i
+const TAG    = /\n<task-plan-tag>[^<]*<\/task-plan-tag>\s*$/
+const HEIGHT = 0.75
+const POLL   = 2000
+const DIGITS = 2
+const WIDE   = 1000
+const DIM    = "ansi256(244)"
+const ACCENT = "ansi256(4)"
+const SIGNAL = PICKED
+const REMOVE = "ansi256(1)"
+const ADDBG  = "ansi256(194)"
+const DELBG  = "ansi256(224)"
+const ADDWD  = "ansi256(157)"
+const DELWD  = "ansi256(217)"
+const DELFG  = "ansi256(16)"
+const ALIKE  = 0.4
+
+/*  a task band: the scroll state of its frame, the task, the plan sections under
+    focus (empty for the entire task), the loaded task and its predecessor (if it
+    already changed), and the lines of the task with the digits of their line
+    numbers and the band columns they were wrapped for  */
+type Band = View & {
+    id:       string,
+    sections: string[],
+    loaded:   string,
+    before:   string | undefined,
+    lines:    Char[][],
+    digits:   number,
+    columns:  number
+}
+
+/*  make a text safe for the terminal: expand tabs and strip control characters
+    (a copy of "sanitize" of "tool/src/ase-task-board-tui-popup.ts", so keep it in sync)  */
+const sanitize = (text: string): string =>
+    text.replace(/\t/g, "    ").replace(/[\p{Cc}\u{061C}\u{200E}\u{200F}\u{202A}-\u{202E}\u{2066}-\u{2069}]/gu, "")
+
+/*  a shown row of a task: its styled characters and the line of the task text it
+    shows, as seen in the editor (absent for the continuation of a wrapped line)  */
+type Row = { chars: Char[], number: number | undefined }
+
+/*  split a task into the keys of its frontmatter (without "Type"), each with its
+    line, and its body with its first line (without the backmatter, which starts
+    at the first "---" line outside a fenced code block)  */
+const parts = (source: string): { keys: [ string, string, number ][], body: string, first: number } => {
+    const head  = /^---\n([^]*?)\n---\n/.exec(source)
+    const lines = source.slice(head?.[0].length ?? 0).split("\n")
+    let fence   = false
+    const end   = lines.findIndex((line) => {
+        if (line.startsWith("```"))
+            fence = !fence
+        return !fence && line === "---"
+    })
+    return {
+        keys: (head?.[1] ?? "").split("\n").flatMap((line, k): [ string, string, number ][] => {
+            const m = /^([^:\s]+):\s*(.*)$/.exec(line)
+            return m !== null && m[1] !== "Type" ? [ [ m[1]!, m[2]!, k + 2 ] ] : []
+        }),
+        body:  (end === -1 ? lines : lines.slice(0, end)).join("\n"),
+        first: head?.[0].split("\n").length ?? 1
+    }
+}
+
+/*  convert inline Markdown (code spans, bold, and italic) into styled characters  */
+const inline = (text: string, bold: boolean, color: string | undefined): Char[] => {
+    const chars: Char[] = []
+    let last = 0
+    for (const m of text.matchAll(/`([^`]+)`|\*\*(.+?)\*\*|__(.+?)__|\*([^*\s](?:[^*]*?[^*\s])?)\*/g)) {
+        chars.push(...uniform(text.slice(last, m.index), bold, color))
+        const body = uniform(m[1] ?? m[2] ?? m[3] ?? m[4]!, bold || m[2] !== undefined || m[3] !== undefined,
+            m[1] !== undefined ? ACCENT : color)
+        chars.push(...(m[4] !== undefined ? body.map((char) => ({ ...char, italic: true })) : body))
+        last = m.index + m[0].length
+    }
+    chars.push(...uniform(text.slice(last), bold, color))
+    return chars
+}
+
+/*  convert a list marker into styled characters, where a checkbox of an item which
+    is done, in progress, or open is accented, and any other checkbox is signaled  */
+const marker = (prefix: string): Char[] => {
+    const chars = uniform(prefix, false, undefined)
+    const m     = /^(\s*(?:[-*]|\d+[.)])\s+)\[(.)\]/.exec(prefix)
+    if (m !== null)
+        for (let k = m[1]!.length; k < m[1]!.length + 3; k++)
+            chars[k] = { ...chars[k]!, color: /[x/ ]/.test(m[2]!) ? ACCENT : SIGNAL }
+    return chars
+}
+
+/*  convert a Markdown body, starting at the given line of the task text, into rows,
+    hard-wrapped to the given columns (except for the lines of fenced code blocks)  */
+const markdown = (body: string, columns: number, first: number): Row[] => {
+    const rows: Row[]  = []
+    const lines        = body.split("\n")
+    const wrapped      = (chars: Char[][], number: number): Row[] =>
+        chars.map((chars, k) => ({ chars, number: k === 0 ? number : undefined }))
+    let fence = false
+    if (lines.at(-1) === "")
+        lines.pop()
+    for (const [ k, line ] of lines.entries()) {
+        const number  = first + k
+        const heading = /^(#{1,6})[ \t]+/.exec(line)
+        const prefix  = /^\s*(?:(?:[-*]|\d+[.)])\s+(?:\[.\]\s+)?)?/.exec(line)![0]
+        if (line.trimStart().startsWith("```"))
+            fence = !fence
+        else if (fence)
+            rows.push({ chars: uniform(line, false, ACCENT), number })
+        else if (line.trim() === "")
+            rows.push({ chars: [], number })
+        else if (heading !== null)
+            rows.push(...wrapped(wrap(inline(line.slice(heading[0].length), true,
+                heading[1]!.length <= 4 ? ACCENT : undefined), columns, 0), number))
+        else {
+            const text = wrap(inline(line.slice(prefix.length), false, undefined), columns, prefix.length, prefix.length)
+            text[0]!.splice(0, prefix.length, ...marker(prefix))
+            rows.push(...wrapped(text, number))
+        }
+    }
+    return rows
+}
+
+/*  convert a task into rows, hard-wrapped to the given columns: under a focus only
+    the focused sections (in plan order), else the keys of the frontmatter (each cut
+    to the columns), a rule for its end, and the body, all without trailing blank rows  */
+const page = (task: string, sections: string[], columns: number): Row[] => {
+    const { keys, body, first } = parts(task.replace(TAG, "").split("\n").map(sanitize).join("\n"))
+    const rows: Row[] = []
+    if (sections.length > 0) {
+        let line = first
+        for (const part of body.split(/^(?=##\s)/m)) {
+            if (sections.includes(/^##\s+(\S+)/.exec(part)?.[1] ?? ""))
+                rows.push(...markdown(part, columns, line))
+            line += part.split("\n").length - 1
+        }
+    }
+    else {
+        for (const [ key, val, number ] of keys) {
+            const text = `${`${key}:`.padEnd(11)}${val}`
+            rows.push({ chars: uniform(text.length > columns ? `${text.slice(0, Math.max(0, columns - 1))}…` : text, false, DIM), number })
+        }
+        if (keys.length > 0)
+            rows.push({ chars: uniform("─".repeat(columns), false, DIM), number: first - 1 })
+        rows.push(...markdown(body, columns, first))
+    }
+    while (rows.at(-1)?.chars.length === 0)
+        rows.pop()
+    return rows
+}
+
+/*  prefix a line with its line number (if any): grey for an unchanged line, resp.
+    colored for a changed line, whose number and text get a background over all
+    columns (except for its already emphasized words)  */
+const numbered = (line: Char[], number: number | undefined, digits: number, columns: number, sign?: "-" | "+"): Char[] => {
+    const cell = (number !== undefined ? String(number) : "").padStart(digits)
+    if (sign === undefined)
+        return [ ...uniform(cell, false, DIM), ...line ]
+    const background = sign === "-" ? DELBG : ADDBG
+    return [
+        ...uniform(cell, false, sign === "-" ? REMOVE : ACCENT),
+        ...line,
+        ...uniform(" ".repeat(Math.max(0, columns - width(line))), false, undefined)
+    ].map((char) => ({ ...char, background: char.background ?? background }))
+}
+
+/*  align two lists of strings along the longest common subsequence between their
+    common ends, into steps of a kept, removed, or added string (with the removed
+    before the added strings of a change)  */
+type Step = { sign: " " | "-" | "+", i: number, j: number }
+const align = (a: string[], b: string[]): Step[] => {
+    let head = 0
+    while (head < a.length && head < b.length && a[head] === b[head])
+        head++
+    let tail = 0
+    while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail])
+        tail++
+    const n    = a.length - head - tail
+    const m    = b.length - head - tail
+    const span = m + 1
+    const lcs  = new Uint32Array((n + 1) * span)
+    for (let i = n - 1; i >= 0; i--)
+        for (let j = m - 1; j >= 0; j--)
+            lcs[i * span + j] = a[head + i] === b[head + j] ? lcs[(i + 1) * span + j + 1]! + 1 :
+                Math.max(lcs[(i + 1) * span + j]!, lcs[i * span + j + 1]!)
+    const steps: Step[] = Array.from({ length: head }, (_, k) => ({ sign: " ", i: k, j: k }))
+    let i = 0
+    let j = 0
+    while (i < n || j < m) {
+        if (i < n && j < m && a[head + i] === b[head + j])
+            steps.push({ sign: " ", i: head + i++, j: head + j++ })
+        else if (i < n && (j === m || lcs[(i + 1) * span + j]! >= lcs[i * span + j + 1]!))
+            steps.push({ sign: "-", i: head + i++, j: head + j })
+        else
+            steps.push({ sign: "+", i: head + i, j: head + j++ })
+    }
+    for (let k = tail; k > 0; k--)
+        steps.push({ sign: " ", i: a.length - k, j: b.length - k })
+    return steps
+}
+
+/*  split lines into their words and other non-blank characters, each with its position  */
+type Token = { text: string, row: number, from: number, to: number }
+const tokens = (lines: Char[][]): Token[] => lines.flatMap((line, row) => {
+    const list: Token[] = []
+    for (let from = 0, to = 0; from < line.length; from = to) {
+        to = from + 1
+        if (/[\p{L}\p{N}_]/u.test(line[from]!.ch))
+            while (to < line.length && /[\p{L}\p{N}_]/u.test(line[to]!.ch))
+                to++
+        if (line[from]!.ch !== " ")
+            list.push({ text: line.slice(from, to).map((char) => char.ch).join(""), row, from, to })
+    }
+    return list
+})
+
+/*  emphasize the changed words of the removed and added lines of a change (and the
+    blanks between adjacent ones), unless too many of the words changed, where the
+    words alone decide, so a change of the wrapping only emphasizes nothing  */
+const emphasize = (removed: Char[][], added: Char[][]): [ Char[][], Char[][] ] => {
+    const a     = tokens(removed)
+    const b     = tokens(added)
+    const steps = align(a.map((token) => token.text), b.map((token) => token.text))
+    if (steps.filter(({ sign }) => sign !== " ").length > (a.length + b.length) * ALIKE)
+        return [ removed, added ]
+    const del = removed.map((line) => [ ...line ])
+    const add = added.map((line) => [ ...line ])
+    let last: Token | undefined
+    let kind = " "
+    for (const { sign, i, j } of steps) {
+        const token = sign === "-" ? a[i]! : sign === "+" ? b[j]! : undefined
+        if (token !== undefined) {
+            const line = (sign === "-" ? del : add)[token.row]!
+            for (let k = kind === sign && last?.row === token.row ? last.to : token.from; k < token.to; k++)
+                line[k] = sign === "-" ? { ...line[k]!, color: DELFG, background: DELWD } : { ...line[k]!, background: ADDWD }
+        }
+        last = token
+        kind = sign
+    }
+    return [ del, add ]
+}
+
+/*  merge the old and the new rows of a task into the lines of their unified diff,
+    each with its line number (the old one for a removed row, else the new one),
+    where only the shown characters of the rows decide about a change  */
+const diff = (before: Row[], after: Row[], digits: number, columns: number): Char[][] => {
+    const lines: Char[][] = []
+    let removed: Row[]    = []
+    let added: Row[]      = []
+    const flush = () => {
+        const [ del, add ] = emphasize(removed.map((row) => row.chars), added.map((row) => row.chars))
+        lines.push(
+            ...del.map((line, k) => numbered(line, removed[k]!.number, digits, columns, "-")),
+            ...add.map((line, k) => numbered(line, added[k]!.number, digits, columns, "+")))
+        removed = []
+        added   = []
+    }
+    for (const { sign, i, j } of align(before.map((row) => JSON.stringify(row.chars)), after.map((row) => JSON.stringify(row.chars)))) {
+        if (sign === "-")
+            removed.push(before[i]!)
+        else if (sign === "+")
+            added.push(after[j]!)
+        else {
+            flush()
+            lines.push(numbered(after[j]!.chars, after[j]!.number, digits, columns))
+        }
+    }
+    flush()
+    return lines
+}
+
+/*  the task band: its state and its operations  */
+export const modTaskEdit = () => {
+    /*  the currently shown band and the timer following the changes of its task  */
+    let shown: Band | undefined
+    let timer: Timer | undefined
+
+    /*  determine whether the task band is shown  */
+    const active = () => shown !== undefined
+
+    /*  close the task band  */
+    const reset = () => {
+        timer?.cancel()
+        timer = undefined
+        shown = undefined
+    }
+
+    /*  show the task band of a task and follow the changes of the task, where an
+        update keeps the scroll position, and determine the answer of the tool  */
+    const open = async (id: string, sections: string,
+        engine: Pick<Engine, "load" | "every" | "invalidate">): Promise<string> => {
+        const loaded = await engine.load(id)
+        if (!TAG.test(loaded))
+            return `ERROR: task "${id}" cannot be loaded`
+        reset()
+        const band: Band = { id, sections: sections.split(",").map((name) => name.trim()).filter((name) => name !== ""),
+            loaded, before: undefined, lines: [], digits: DIGITS, columns: 0, top: 0, scroll: 0, page: 1, split: 0 }
+        shown = band
+        let busy = false
+        timer = engine.every(POLL, () => {
+            if (busy)
+                return
+            busy = true
+            engine.load(id).then((text) => {
+                if (shown === band && text !== band.loaded && TAG.test(text)) {
+                    /*  a change without any shown effect (like a usage booking in
+                        an attachment) keeps the last change and its diff  */
+                    if (JSON.stringify(page(text, band.sections, WIDE)) !==
+                        JSON.stringify(page(band.loaded, band.sections, WIDE))) {
+                        band.before  = band.loaded
+                        band.columns = 0
+                        engine.invalidate()
+                    }
+                    band.loaded = text
+                }
+            }).catch(() => {
+                /*  ignore a task store which is temporarily not accessible  */
+            }).finally(() => {
+                busy = false
+            })
+        })
+        engine.invalidate()
+        return `OK: showing task "${id}" in the band above the prompt`
+    }
+
+    /*  close the task band once a next step of the skill is submitted at the prompt  */
+    const submit = (text: string): void => {
+        if (CLOSE.test(text.trim()))
+            reset()
+    }
+
+    /*  drop the diff of the last change from the task band, so just the latest state
+        remains, once "##" is typed (not pasted with other text) at the end of the
+        prompt, and remove it from there again  */
+    const edit = (box: PromptBox, input: string): PromptBox => {
+        if (shown === undefined || !/^#{1,2}$/.test(input) || box.cursor !== box.text.length || !box.text.endsWith("##"))
+            return box
+        shown.before  = undefined
+        shown.columns = 0
+        const text = box.text.slice(0, -2)
+        return { ...box, text, cursor: text.length }
+    }
+
+    /*  scroll the task in the band by the wheel
+        (and tell whether the band took the scrolling)  */
+    const scroll = (e: BandScroll): boolean => {
+        if (shown === undefined)
+            return false
+        wheel(e, shown)
+        return true
+    }
+
+    /*  draw the task into the band above the prompt (terminal only), yielding to a survey,
+        with a blank row (taken from the rows of the view) separating it from the transcript  */
+    const render = (e: BandRender, ui: Elements["terminal"]): RenderElement | undefined => {
+        if (shown === undefined || e.props.hasSurvey)
+            return undefined
+        const geometry = layout(e, 0, HEIGHT)
+        geometry.body  = Math.max(1, geometry.body - 1)
+        if (shown.columns !== geometry.span) {
+            const { before, loaded, sections } = shown
+            const largest = (task: string) => Math.max(0, ...page(task, sections, WIDE).map((row) => row.number ?? 0))
+            const digits  = Math.max(DIGITS, String(Math.max(largest(loaded), largest(before ?? loaded))).length)
+            const columns = geometry.span - 4 - digits
+            const rows    = page(loaded, sections, columns)
+            shown.lines   = diff(before !== undefined ? page(before, sections, columns) : rows, rows, digits, columns)
+            shown.digits  = digits
+            shown.columns = geometry.span
+        }
+        return ui.Box({ flexDirection: "column", width: "100%", children: [
+            ui.Text({ children: " " }),
+            panel(ui, geometry, shown, {
+                title: `[ ⧉ ASE: Edit Task: ${shown.id}${shown.sections.length > 0 ? ` (${shown.sections.join(", ")})` : ""} ]`,
+                hints: (geometry.overflow ? "wheel or CTRL+x + TAB + ↑/↓/PgUp/PgDn: scroll · " : "") +
+                    (shown.before !== undefined ? "##: clear diff · " : "") +
+                    "DONE · GRILL · DRAFT · IMPLEMENT · CANCEL · (type for refining)",
+                lines: shown.lines,
+                gutter: shown.digits
+            })
+        ] })
+    }
+
+    return { active, reset, open, submit, edit, scroll, render }
+}

package/plugin/mods/ase-mods.ts

@@ -6,24 +6,26 @@
 
 /*  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 decision matrix
-    ("ase-mods-evaluate.ts"), the intent help ("ase-mods-help-find.ts"),
+    them into the grill table ("ase-mods-task-grill.ts"), the decision matrix
+    ("ase-mods-meta-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").
+    ("ase-mods-help-browse.ts"), the hint band ("ase-mods-help-hint.ts"),
+    and the task band ("ase-mods-task-edit.ts").
     As the engine loads only a module spelling "on", "$", and "next" literally,
     this is the only module touching the engine, and it binds the engine
     services needed by the other modules as plain functions.  */
 
 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 { modGrill }           from "./ase-mods-task-grill.ts"
+import { modEvaluate }        from "./ase-mods-meta-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"
 import { modHelpBrowse }      from "./ase-mods-help-browse.ts"
 import { modHelpHint }        from "./ase-mods-help-hint.ts"
+import { modTaskEdit, TOOL }  from "./ase-mods-task-edit.ts"
 
 /*  function hook registration entry point  */
 export const register: Register = (on, options) => {
@@ -32,7 +34,7 @@ export const register: Register = (on, options) => {
         return
 
     /*  the grill table, the decision matrix, the intent help, the synopsis form,
-        the manual band, the manpage browser, and the hint band  */
+        the manual band, the manpage browser, the hint band, and the task band  */
     const grill    = modGrill()
     const evaluate = modEvaluate()
     const intent   = modHelpFind()
@@ -40,6 +42,27 @@ export const register: Register = (on, options) => {
     const manual   = modHelpShow()
     const browse   = modHelpBrowse()
     const hint     = modHelpHint()
+    const task     = modTaskEdit()
+
+    /*  provide the tool of the task band where a person sees the band only, so
+        its absence tells "ase-task-edit --interactive" that no band exists  */
+    on("session.start", async ($, e, next) => {
+        if (e.isInteractive && e.surface === "terminal")
+            await $.tool.register(TOOL)
+        return next(e)
+    })
+
+    /*  serve the tool of the task band, which needs no permission, as it just
+        shows a task, and whose loading of the task is as harmless  */
+    on("tool.check", { tool: "mcp__ase__ase_task_band" }, () => ({ decision: "allow" }))
+    on("tool.call", { tool: "mcp__ase__ase_task_band" }, async ($, e) => ({
+        result: await task.open(String(e.id), String(e.sections ?? ""), {
+            invalidate: () => $.ui.invalidate("ui.render"),
+            every:      (ms, fn) => $.clock.every(ms, fn),
+            load:       async (id) => (await $.tool.call({ tool: "mcp__plugin_ase_ase__ase_task_load",
+                id, variant: "source", tag: true })).text ?? ""
+        })
+    }))
 
     /*  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
@@ -65,7 +88,8 @@ export const register: Register = (on, options) => {
         (toggling the manual band for a skill command with "//", resp. showing the
         synopsis form for a skill command with a manual page with "!!", else arming
         the matching of the prompt as an intent with "!!", resp. showing the manpage
-        browser for any other prompt with "//"), close the manual band once the
+        browser for any other prompt with "//", resp. dropping the diff of the task
+        band with "##"), close the manual band once the
         prompt left its skill command or another band opened, track the skill
         command of the hint band, and track the picks of the grill table inside
         the edited prompt while no band is shown  */
@@ -95,6 +119,11 @@ export const register: Register = (on, options) => {
         }
         else {
             box = await next(e)
+            const stripped = task.edit(box, e.inputText)
+            if (stripped !== box) {
+                box = stripped
+                $.ui.invalidate("ui.render")
+            }
             if (/[!/]$/.test(e.inputText) && box.cursor === box.text.length && TRIGGER.test(box.text))
                 box = await open(box)
         }
@@ -130,10 +159,10 @@ export const register: Register = (on, options) => {
     })
 
     /*  operate the synopsis form resp. the intent band, else scroll the manual
-        page in the band, by the wheel, and never let the engine move the window
-        over our (overflowing) band, even while it takes no scrolling  */
+        page, else the task, in the band, by the wheel, and never let the engine
+        move the window over our (overflowing) band, even while it takes no scrolling  */
     on("ui.scroll", { component: "AbovePrompt" }, ($, e, next) => {
-        if (!bands.some((band) => band.scroll(e)) && !manual.scroll(e))
+        if (!bands.some((band) => band.scroll(e)) && !manual.scroll(e) && !task.scroll(e))
             return shown() === undefined && !manual.active() ? next(e) : {}
         $.ui.invalidate("ui.render")
         return {}
@@ -194,6 +223,7 @@ export const register: Register = (on, options) => {
         reset()
         manual.reset()
         hint.reset()
+        task.submit(e.text)
         $.ui.invalidate("ui.render")
         return next(e)
     }).catch(($, e, next) =>
@@ -216,19 +246,20 @@ export const register: Register = (on, options) => {
         }) ?? evaluate.render(e, ui, { invalidate }) ?? drawn
     })
 
-    /*  draw the intent band resp. the synopsis form, else the manual page,
-        else the argument hint, into the band above the prompt (terminal only)  */
+    /*  draw the intent band resp. the synopsis form, else the manual page, else
+        the task, else the argument hint, into the band above the prompt (terminal only)  */
     on("ui.render", { component: "AbovePrompt", surface: "terminal" }, async ($, e, next) => {
         const drawn = await next(e)
         const ui    = $.ui.resolve(e)
-        return shown()?.render(e, ui) ?? manual.render(e, ui) ?? hint.render(e, ui) ?? drawn
+        return shown()?.render(e, ui) ?? manual.render(e, ui) ?? task.render(e, ui) ?? hint.render(e, ui) ?? drawn
     }).catch(($, e, next) => {
         /*  close a failed intent band resp. synopsis form, restore the prompt
             resp. the command as typed (instead of the held prompt), resp. close
-            a failed manual band and hint band, and keep the drawing beneath  */
+            a failed manual band, task band, and hint band, and keep the drawing beneath  */
         const text = cancel()
         if (text === undefined) {
             manual.reset()
+            task.reset()
             hint.reset()
         }
         if (text !== undefined)

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`">