@rse/ase 2.0.7 → 2.0.8

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-help-intent/data.md

@@ -4595,6 +4595,9 @@ Dissect a specific task plan with a hint:
     [`--mode`|`-m` `auto`|`craft`|`refactor`|`resolve`|`specify`]
     [`--approach`|`-a`]
     [`--unverified`|`-u`]
+    [`--focus`|`-f` *section*[,...]]
+    [`--quiet`|`-q`]
+    [`--interactive`|`-i`]
     [`--next`|`-n` *option*[,...]]
     [*id* | *id*: *instruction* | *instruction* | *issue-id*]
 
@@ -4679,6 +4682,51 @@ stale draft.
     build, tests, linter, type-checker, or program execution) once
     the source files have been modified.
 
+-   `--focus`|`-f` *section*[,...]:
+    Edit and show only the given plan *section*(s). Each *section* is
+    one of `SPECIFICATION` (also `SPEC` or `WHAT`), `DESIGN` (also `DES`
+    or `HOW`), or `VERIFICATION` (also `VERIFY`, `VER`, or `WHEN`),
+    matched case-sensitively, or the sentinel `all` (default). The shown
+    plan consists only of these sections, including their headings, but
+    without the frontmatter and the title.
+
+    The rest of the plan stays the context, and an *instruction* requiring a
+    change outside of the focus is applied nevertheless and reported by
+    a warning. A new plan gets all section headings, but only the focused
+    sections are populated, and `OVERWRITE` re-generates only them. An
+    unknown, empty, or duplicate *section* token aborts the skill. It is
+    forwarded on a hand-off to `ase-task-grill`, but not on a hand-off
+    to another skill.
+
+-   `--quiet`|`-q`:
+    Do not print the resulting plan at the end of a planning round. The
+    status lines, the dialogs, and the warning on a stale implementation
+    draft stay. It is forwarded on a hand-off to `ase-task-grill`, but
+    not on a hand-off to another skill.
+
+-   `--interactive`|`-i`:
+    Show the plan in a band above the prompt (*Anthropic Claude Code CLI* with
+    active ASE function hooks in an interactive terminal only, else the skill
+    aborts), instead of printing it, and ask for the next step without any
+    dialog. The band takes 75% of the terminal height, in the fullscreen mode
+    all the rows the terminal UI leaves it. Under `--focus`, it shows only the
+    focused sections.
+
+    The band follows every change of the plan, also by others, and keeps its
+    scroll position. Its line numbers are those of the plan text in `ase task
+    edit`. It shows the last change as a unified diff with colored backgrounds and
+    line numbers, red for removed and blue for added lines. In the fullscreen
+    mode, scroll it with the mouse wheel, or with *CTRL+x* *TAB* and then
+    *PageUp*/*PageDown*.
+
+    At the prompt, type either a refinement instruction, or one of `DONE`,
+    `GRILL`, `DRAFT`, `IMPLEMENT`, or `CANCEL` (in any case), which closes the
+    band. After a hand-off to `ase-task-grill`, a hand-off back reopens it.
+
+    Type `##` at the end of the prompt (which removes it again) to remove the
+    unified diff and show just the latest state of the plan, until its next
+    change. The band stays open and the input does not reach the agent.
+
 -   `--next`|`-n` *option*[,...]:
     Automatically answer the user dialog for the next step (at the end
     of this skill). *option* is a single token or a *comma-separated
@@ -4750,6 +4798,18 @@ Plan a refactoring under the id `cleanup`:
 ❯ /ase-task-edit -m refactor cleanup: extract HTTP client into its own class
 ```
 
+Refine and show only the `DESIGN` section of the task under id `hello`:
+
+```text
+❯ /ase-task-edit --focus HOW hello: print the text via a dedicated logger.
+```
+
+Refine the task under id `hello` with its plan shown in a band above the prompt:
+
+```text
+❯ /ase-task-edit --interactive hello
+```
+
 </purpose>
 <purpose name="ase-task-estimate">
 
@@ -4923,6 +4983,7 @@ Calibrate the estimation and store the fitted rates:
     [`--ground`|`-G`]
     [`--focus`|`-f` *section*[,...]]
     [`--force`|`-F`]
+    [`--quiet`|`-q`]
     [`--next`|`-n` *option*[,...]]
     [*id*]
 
@@ -4971,7 +5032,7 @@ persisted, its `Tags:` frontmatter key records each grilled section as
 its own tag `grilled:`*section* (lower-case, kept alongside the tags of
 previously grilled sections, e.g. `grilled:specification,
 grilled:design`), and a `PLAN CHANGES` box shows the bullet-points
-changed by the round. Finally, the user is offered a complete
+changed by the round (unless `--quiet` is given). Finally, the user is offered a complete
 re-grilling (with the same grilling options), or a hand-off to editing,
 implementation, or draft.
 
@@ -5033,19 +5094,28 @@ in state `[-]` (cancelled) or `[>]` (deferred) are never questioned.
 
 -   `--focus`|`-f` *section*[,...]:
     Grill only the given plan *section*(s), in the given order. Each
-    *section* is one of `SPECIFICATION` (abbreviated `SPEC`), `DESIGN`
-    (abbreviated `DES`), or `VERIFICATION` (abbreviated `VER`), matched
-    case-insensitively, or the sentinel `all` (default), which expands
-    to `SPECIFICATION,DESIGN,VERIFICATION`. The questions are derived
-    from the themes of the focused sections only, while the entire plan
-    stays the context, and the answers may still update any section.
-    An unknown, empty, or duplicate *section* token aborts the skill.
+    *section* is one of `SPECIFICATION` (also `SPEC` or `WHAT`), `DESIGN`
+    (also `DES` or `HOW`), or `VERIFICATION` (also `VERIFY`, `VER`, or
+    `WHEN`), matched case-sensitively, or the sentinel `all` (default),
+    which expands to `SPECIFICATION,DESIGN,VERIFICATION`. The questions
+    are derived from the themes of the focused sections only, while the
+    entire plan stays the context, and an answer requiring a change
+    outside of the focus is applied nevertheless and reported by a
+    warning. An unknown, empty, or duplicate *section* token aborts the
+    skill. It is forwarded on a re-grilling and on a hand-off to
+    `ase-task-edit`, but not on a hand-off to another skill.
 
 -   `--force`|`-F`:
     Re-grill already grilled sections completely, i.e., ignore their
     `grilled:`*section* tags instead of skipping them resp. re-asking
     only their `[?]` bullet-points.
 
+-   `--quiet`|`-q`:
+    Do not print the `PLAN CHANGES` box of the bullet-points changed by
+    a round. The status lines and the dialogs stay. It is forwarded on a
+    re-grilling and on a hand-off to `ase-task-edit`, but not on a
+    hand-off to another skill.
+
 -   `--next`|`-n` *option*[,...]:
     Automatically answer the user dialog for the next step (at the end
     of this skill). *option* is a single token or a *comma-separated

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

@@ -1,6 +1,6 @@
 ---
 name: ase-task-edit
-argument-hint: "[--help|-h] [--plan|-p <option>] [--mode|-m auto|craft|refactor|resolve|specify] [--approach|-a] [--unverified|-u] [--next|-n <option>[,...]] [<id> | <id>: <instruction> | <instruction> | <issue-id>]"
+argument-hint: "[--help|-h] [--plan|-p <option>] [--mode|-m auto|craft|refactor|resolve|specify] [--approach|-a] [--unverified|-u] [--focus|-f <section>[,...]] [--quiet|-q] [--interactive|-i] [--next|-n <option>[,...]] [<id> | <id>: <instruction> | <instruction> | <issue-id>]"
 description: >
     Iteratively edit and refine a named plan for a task through a
     conversational loop. A new plan is optionally composed along the
@@ -27,7 +27,7 @@ Iteratively Edit a Task Plan
 
 <expand name="getopt"
     arg1="ase-task-edit"
-    arg2="--plan|-p=(none|OVERWRITE|REFINE|PRESERVE) --mode|-m=(auto|craft|refactor|resolve|specify) --approach|-a --unverified|-u --next|-n=(none|DONE|GRILL|DRAFT|IMPLEMENT)... --int-reuse-task --int-source-dir=">
+    arg2="--plan|-p=(none|OVERWRITE|REFINE|PRESERVE) --mode|-m=(auto|craft|refactor|resolve|specify) --approach|-a --unverified|-u --focus|-f=(all|SPECIFICATION|SPEC|WHAT|DESIGN|DES|HOW|VERIFICATION|VERIFY|VER|WHEN)... --quiet|-q --interactive|-i --next|-n=(none|DONE|GRILL|DRAFT|IMPLEMENT)... --int-reuse-task --int-source-dir=">
     $ARGUMENTS
 </expand>
 
@@ -81,6 +81,19 @@ When refining the plan this way, preserve the overall structure of the
 plan and only modify what the user actually requested. Do *not* rewrite
 unrelated sections of the plan.
 
+<if condition="<getopt-option-focus/> is not equal `all`">
+Restrict the refinement to the sections in <sections/>: all other
+sections and the "backmatter" stay *unchanged* and serve as read-only
+context. Only if the <instruction/> inevitably requires a *foreign
+change* outside of these sections, apply it nevertheless, set <foreign/>
+to the comma-separated names of the changed sections (resp.
+`backmatter`), and only output the following <template/>:
+
+<template>
+⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ WARNING: changed sections outside of focus: **<foreign/>**
+</template>
+</if>
+
 <if condition="<getopt-option-int-source-dir/> is not empty">
 The *code basis* of the task is the separate working copy
 <getopt-option-int-source-dir/> (e.g. a checkout of the branch of its
@@ -212,6 +225,17 @@ then immediately *STOP* processing the entire current skill:
 Set <chosen-approach></chosen-approach> (empty). Do not output anything.
 </else>
 
+<if condition="<getopt-option-focus/> is not equal `all` and <task-content/> is not empty">
+This is the `OVERWRITE` of an existing plan under a focus, so re-generate
+*only* the sections in <sections/> of <task-content/> in-place, by
+closely following the defined plan format <format/> and injecting into
+them all the information from the <instruction/>, the <chosen-approach/>
+(if not empty), all decisions you derived from the <instruction/> and the
+<chosen-approach/>, and the grounding in the project. All other sections,
+the "backmatter", and all other frontmatter keys stay *unchanged*. Set the
+`Kind:` frontmatter key to <task-kind/>.
+</if>
+<else>
 Create a new plan from scratch and store the result as
 <task-content/> by closely following the defined plan format
 <format/> and injecting into it all the information from
@@ -220,6 +244,14 @@ decisions you derived from the <instruction/> and the <chosen-approach/>, and
 the grounding in the project. Set the `Kind:` frontmatter key to
 <task-kind/>.
 
+<if condition="<getopt-option-focus/> is not equal `all`">
+Populate *only* the sections in <sections/> and keep all other sections
+*empty*, i.e., as bare `##` headings without any bullet-points, until a
+later round focuses them. Hence, the `CHANGELOG.md` bullet-point of the
+grounding above is due only if `DESIGN` is in <sections/>.
+</if>
+</else>
+
 <if condition="<task-kind/> is equal `RESOLVING`">
 The plan *MUST* carry code references, a precise description of the
 problem, the resolution approach, a preview of the *unified
@@ -238,7 +270,8 @@ Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
 `ase` MCP server and use the `text` field of its response
 for fresh <timestamp-created/> and <timestamp-modified/>
 information. Then insert the current <ase-task-id/>,
-<timestamp-created/>, and <timestamp-modified/> information.
+<timestamp-created/>, and <timestamp-modified/> information -- except
+for the `OVERWRITE` under a focus above, which keeps the `Created:` key.
 Set <task-content-dirty>true</task-content-dirty>.
 </define>
 
@@ -262,6 +295,23 @@ Set <args></args> (set args to empty).
         Inherit the always existing <ase-session-id/> from the current context.
         Do not output anything.
 
+        <expand name="task-focus" arg1="ase-task-edit"></expand>
+
+        Set <band-open>false</band-open>.
+        <if condition="<getopt-option-interactive/> is `true`">
+        The band of `--interactive` is drawn by the function hooks module
+        of the plugin, which provides the `mcp__ase__ase_task_band` tool
+        in an interactive terminal only. Load the schema of this tool (if
+        deferred, via `ToolSearch` with the query
+        `select:mcp__ase__ase_task_band`). If this tool does not exist,
+        only output the following <template/> and then immediately *STOP*
+        processing the entire current skill:
+
+        <template>
+        ⧉ **ASE**: ☻ skill: **ase-task-edit**, ▶ ERROR: `--interactive` requires the active ASE function hooks in an interactive terminal
+        </template>
+        </if>
+
     2.  Resolve a potential analyzer issue:
 
         <if condition="
@@ -647,6 +697,7 @@ Set <args></args> (set args to empty).
         silently *skip* this entire step 3.3 (no MCP tool call and no
         output at all) and continue with step 3.4.
 
+        <if condition="<getopt-option-quiet/> is not equal `true` and <getopt-option-interactive/> is not equal `true`">
         <if condition="<task-render/> is empty">
         Call the `ase_markdown_prepare(text: "<task-content/>")` tool of
         the `ase` MCP server and set <task-render/> to the `text` output
@@ -684,22 +735,34 @@ Set <args></args> (set args to empty).
         ⇥   **Target:**    <task-target/>
         </format>
 
+        Set <focus-label></focus-label> (empty).
+        <if condition="<getopt-option-focus/> is not equal `all`">
+        For the *rendering only*, overriding the above, additionally drop
+        the glyph lines, the `#   TASK: <title/>` heading, every `##`
+        section whose name is *not* in <sections/>, and the entire
+        "backmatter", keeping the remaining sections, including their
+        `##` headings, in their plan order, and set <focus-label/> to
+        ` (<names/>)`, with <names/> being the comma-separated names of
+        these remaining sections.
+        </if>
+
         Only output the following <template/>, so the user
         can read the plan and react to it. Do *not* truncate,
-        summarize, or partially show the plan. Use the
-        following <template/>:
+        summarize, or partially show the plan, beyond the focus
+        above. Use the following <template/>:
 
         <template>
-        <ase-tpl-head title="TASK" subtitle="<task-id/>"/>
+        <ase-tpl-head title="TASK" subtitle="<task-id/><focus-label/>"/>
         <task-render/>
-        <ase-tpl-foot title="TASK" subtitle="<task-id/>"/>
+        <ase-tpl-foot title="TASK" subtitle="<task-id/><focus-label/>"/>
         </template>
+        </if>
 
         <if condition="the backmatter of <task-content/> contains an attachment
             block with the `Type` key value `text/x-diff; charset=utf-8; kind="draft"`
             which is *stale* according to the plan <format/> (its `Modified` key
             is absent or older than the `Modified` key of the frontmatter)">
-        Directly *after* this <template/>, only output the following
+        Directly *after* any rendering, only output the following
         <template/> and then give the corrective hint by expanding the
         subsequent construct (which, depending on the configured
         <ase-guidance-level/>, may expand into nothing and hence emit
@@ -742,7 +805,40 @@ Set <args></args> (set args to empty).
                 ⧉ **ASE**: ☻ skill: **ase-task-edit**, ▶ ERROR: invalid `--next` token: **<head/>**
                 </template>
 
-        -   If <getopt-option-next/> is equal to `none`:
+        -   If <getopt-option-next/> is equal to `none` and <getopt-option-interactive/> is `true`:
+
+            <if condition="<band-open/> is `false`">
+            Call the `mcp__ase__ase_task_band(id: "<ase-task-id/>")` tool --
+            if <getopt-option-focus/> is not equal `all`, additionally with
+            the argument `sections: "<sections/>"` -- to show the plan in the
+            band above the prompt, which from now on follows every change of
+            the plan on its own, and set <band-open>true</band-open>. If its
+            `text` output field starts with `ERROR: <info/>`, only output the
+            following <template/> and then immediately *STOP* processing the
+            entire current skill:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ ERROR: **<info/>**
+            </template>
+            </if>
+
+            Do *not* show any dialog. Only output the following <template/>,
+            end the current turn, wait for the user input, and store the
+            user input in <result/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **awaiting instruction**
+            </template>
+
+            If <result/>, with any leading and trailing whitespace stripped,
+            case-insensitively equals `DONE`, `GRILL`, `DRAFT`, `IMPLEMENT`,
+            or `CANCEL` -- exactly the inputs on which the band closes on its
+            own -- set <result/> to this upper-case token. Otherwise, set
+            <result>OTHER: <result/></result>, also for an input which merely
+            indicates that the user does not want to proceed, as the band
+            stays open on it.
+
+        -   If <getopt-option-next/> is equal to `none` and <getopt-option-interactive/> is not `true`:
 
             In the following, you *MUST* *NOT* use your built-in
             <user-dialog-tool/> tool! Instead, you *MUST* just show a
@@ -772,6 +868,15 @@ Set <args></args> (set args to empty).
 
             *Break* out of the *loop*.
             <expand name="handoff-args"/>
+            <if condition="<getopt-option-quiet/> is `true`">
+                Set <args><args/> --quiet</args>.
+            </if>
+            <if condition="<getopt-option-interactive/> is `true`">
+                Set <args><args/> --int-interactive</args>.
+            </if>
+            <if condition="<getopt-option-focus/> is not equal `all`">
+                Set <args><args/> --focus <getopt-option-focus/></args>.
+            </if>
             Only output the following <template/> and then call the
             `Skill(skill: "ase:ase-task-grill", args: "<args/>")` tool
             to *grill* the finalized plan.

package/plugin/skills/ase-task-edit/help.md

@@ -11,6 +11,9 @@
     [`--mode`|`-m` `auto`|`craft`|`refactor`|`resolve`|`specify`]
     [`--approach`|`-a`]
     [`--unverified`|`-u`]
+    [`--focus`|`-f` *section*[,...]]
+    [`--quiet`|`-q`]
+    [`--interactive`|`-i`]
     [`--next`|`-n` *option*[,...]]
     [*id* | *id*: *instruction* | *instruction* | *issue-id*]
 
@@ -95,6 +98,51 @@ stale draft.
     build, tests, linter, type-checker, or program execution) once
     the source files have been modified.
 
+-   `--focus`|`-f` *section*[,...]:
+    Edit and show only the given plan *section*(s). Each *section* is
+    one of `SPECIFICATION` (also `SPEC` or `WHAT`), `DESIGN` (also `DES`
+    or `HOW`), or `VERIFICATION` (also `VERIFY`, `VER`, or `WHEN`),
+    matched case-sensitively, or the sentinel `all` (default). The shown
+    plan consists only of these sections, including their headings, but
+    without the frontmatter and the title.
+
+    The rest of the plan stays the context, and an *instruction* requiring a
+    change outside of the focus is applied nevertheless and reported by
+    a warning. A new plan gets all section headings, but only the focused
+    sections are populated, and `OVERWRITE` re-generates only them. An
+    unknown, empty, or duplicate *section* token aborts the skill. It is
+    forwarded on a hand-off to `ase-task-grill`, but not on a hand-off
+    to another skill.
+
+-   `--quiet`|`-q`:
+    Do not print the resulting plan at the end of a planning round. The
+    status lines, the dialogs, and the warning on a stale implementation
+    draft stay. It is forwarded on a hand-off to `ase-task-grill`, but
+    not on a hand-off to another skill.
+
+-   `--interactive`|`-i`:
+    Show the plan in a band above the prompt (*Anthropic Claude Code CLI* with
+    active ASE function hooks in an interactive terminal only, else the skill
+    aborts), instead of printing it, and ask for the next step without any
+    dialog. The band takes 75% of the terminal height, in the fullscreen mode
+    all the rows the terminal UI leaves it. Under `--focus`, it shows only the
+    focused sections.
+
+    The band follows every change of the plan, also by others, and keeps its
+    scroll position. Its line numbers are those of the plan text in `ase task
+    edit`. It shows the last change as a unified diff with colored backgrounds and
+    line numbers, red for removed and blue for added lines. In the fullscreen
+    mode, scroll it with the mouse wheel, or with *CTRL+x* *TAB* and then
+    *PageUp*/*PageDown*.
+
+    At the prompt, type either a refinement instruction, or one of `DONE`,
+    `GRILL`, `DRAFT`, `IMPLEMENT`, or `CANCEL` (in any case), which closes the
+    band. After a hand-off to `ase-task-grill`, a hand-off back reopens it.
+
+    Type `##` at the end of the prompt (which removes it again) to remove the
+    unified diff and show just the latest state of the plan, until its next
+    change. The band stays open and the input does not reach the agent.
+
 -   `--next`|`-n` *option*[,...]:
     Automatically answer the user dialog for the next step (at the end
     of this skill). *option* is a single token or a *comma-separated
@@ -166,6 +214,18 @@ Plan a refactoring under the id `cleanup`:
 ❯ /ase-task-edit -m refactor cleanup: extract HTTP client into its own class
 ```
 
+Refine and show only the `DESIGN` section of the task under id `hello`:
+
+```text
+❯ /ase-task-edit --focus HOW hello: print the text via a dedicated logger.
+```
+
+Refine the task under id `hello` with its plan shown in a band above the prompt:
+
+```text
+❯ /ase-task-edit --interactive hello
+```
+
 ##  SEE ALSO
 
 [`ase-code-edit`](../ase-code-edit/help.md), [`ase-spec-edit`](../ase-spec-edit/help.md), [`ase-task-grill`](../ase-task-grill/help.md),