@rse/ase 1.0.7 → 2.0.0

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

@@ -0,0 +1,158 @@
+
+##  NAME
+
+`ase-task-estimate` - Estimate the Effort of a Task Plan
+
+##  SYNOPSIS
+
+`ase-task-estimate`
+    [`--help`|`-h`]
+    [`--force`|`-f`]
+    [`--dry-run`|`-d`]
+    [`--all`|`-a`]
+    [*id* ...]
+
+`ase-task-estimate`
+    `--calibrate`|`-c`
+    [`--save`|`-s`]
+
+##  DESCRIPTION
+
+The `ase-task-estimate` skill *estimates* the effort of task plans and
+stores it in their `Effort:` frontmatter key. The effort is the expected
+*human time* of the *entire* lifecycle of a task (including its
+planning), matching the human time `time.hr` booked on the usage
+attachment of the task (see `ase-task-assign`), expressed as one of the
+T-shirt sizes `XS`, `S`, `M`, `L`, or `XL`. The sizes are bands on a
+*logarithmic* scale with the upper bounds `15`, `60`, `240`, and `960`
+human minutes for `XS` to `L` (configuration `project.task.effort.scale`),
+while `XL` is open-ended. A task without an `Effort:` key is *not
+estimated*.
+
+The estimation of a plan combines:
+
+-   an *attention score*: the weighted number of the distinct
+    requirements, behaviors, or changes stated by its checklist items
+    (`DOM` 5.0, `IFC` 4.0, `ARC` 3.0, `IMP` 1.0, `REG` 0.5, `CON` 1.0),
+    converted via `project.task.effort.factor` (default: `1`) human
+    minutes per point,
+
+-   a *volume score*: the code impact of its `ARC` and `IMP` items,
+    predicted read-only from the plan and the code base (never measured
+    from an already existing change set), converted via
+    `project.task.effort.file` (default: `1`) human review minutes per
+    touched file and `project.task.effort.line` (default: `0.025`)
+    human minutes per predicted changed line, which also cover the edge
+    cases and polishing no plan describes, where a newly written line
+    weighs three times a changed one,
+
+-   a *risk surcharge*: 20% more per applying risk out of `dependency`,
+    `ambiguity`, `untested`, `concurrency`, `security`, and
+    `persistence`, but at most 40% in total, where risks applying to
+    virtually every task of the project do not count,
+
+-   an *iteration multiplier*: `project.task.effort.iteration`
+    (default: `2.5`) times the minutes for a task whose main
+    deliverable is an interactive or visual user interface, as such
+    work needs many rounds of post-adjustment,
+
+-   a *plausibility check*: a comparable realization already existing
+    in the code base, whose deviating size lowers the reported
+    *confidence*, and
+
+-   *analogues*: finished tasks with an effort and a usage attachment,
+    whose disagreement lowers the reported *confidence*.
+
+Cancelled (`[-]`) and deferred (`[>]`) items never count. The skill
+reports the size, the confidence, and the main drivers of each
+estimation, and for `XL` additionally warns and suggests splitting the
+task via `ase-task-dissect` -- an `XL` effort never blocks the
+lifecycle.
+
+The effort is *bound* to the plan content it was given for: once the
+plan content changes, the effort becomes *invalid* and is dropped, while
+mere checkbox state changes and whitespace-only edits keep it. Hence,
+an estimation never needs to be cleaned up by hand. Writing the effort
+neither changes the `Modified:` key nor the lifecycle status of a task.
+Empty plans and explicit epic tasks (whose effort is the sum of their
+member tasks) are skipped, and so are tasks already carrying a valid
+effort, unless `--force` is given.
+
+With `--calibrate`, the skill instead re-estimates the successfully
+finished tasks with the *current* rates and compares the results with
+their *actual* human time (only tasks with at least `5` human minutes
+count, as agent-driven tasks book little human time), so a repeated
+calibration converges, and reports the estimated vs. actual band matrix,
+the hit rate, the bias, the best-fitting rates (factor, file, and line
+minutes), and alternatively fitting scale bounds.
+
+The `ase agent estimator` command estimates the tasks automatically in
+the background, and with `--mode request` on request, in any unfinished
+status, via `ase task request <id> estimate <prompt>` or key `R` of the
+task boards.
+
+##  OPTIONS
+
+-   `--force`|`-f`:
+    Re-estimate tasks which already carry a valid effort.
+
+-   `--dry-run`|`-d`:
+    Estimate and report only, but do not store the effort.
+
+-   `--all`|`-a`:
+    Estimate all unfinished tasks without a valid effort (with `--force`,
+    all unfinished tasks), instead of the current or given ones.
+
+-   `--calibrate`|`-c`:
+    Report the calibration of the estimation against the finished tasks
+    instead of estimating any task.
+
+-   `--save`|`-s`:
+    Together with `--calibrate`, store the fitted rates as
+    `project.task.effort.factor`, `project.task.effort.file`, and
+    `project.task.effort.line` on the `project` scope. The fitted scale
+    bounds always stay a suggestion only.
+
+##  ARGUMENTS
+
+-   *id* ...:
+    The unique identifiers of the tasks to estimate. If omitted (and
+    without `--all`), the *current* task is estimated.
+
+##  SCENARIOS
+
+-   You want to know how much human time a planned task will need
+-   You want to size all open tasks for planning a sprint or release
+-   You want to check whether a task is too large and should be split
+-   You want to tune the estimation to the actual pace of your team
+
+##  EXAMPLES
+
+Estimate the current task plan:
+
+```text
+❯ /ase-task-estimate
+```
+
+Estimate all unestimated tasks, without storing the results:
+
+```text
+❯ /ase-task-estimate --all --dry-run
+```
+
+Re-estimate two specific tasks:
+
+```text
+❯ /ase-task-estimate --force export-json import-csv
+```
+
+Calibrate the estimation and store the fitted rates:
+
+```text
+❯ /ase-task-estimate --calibrate --save
+```
+
+##  SEE ALSO
+
+[`ase-task-view`](../ase-task-view/help.md), [`ase-task-list`](../ase-task-list/help.md), [`ase-task-dissect`](../ase-task-dissect/help.md),
+[`ase-task-assign`](../ase-task-assign/help.md), [`ase-meta-config`](../ase-meta-config/help.md).

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

@@ -1,6 +1,6 @@
 ---
 name: ase-task-grill
-argument-hint: "[--help|-h] [--rounds|-r <n>] [--next|-n <option>[,...]] [<id>]"
+argument-hint: "[--help|-h] [--rounds|-r <n>] [--until|-u MUST|SHOULD|MAY] [--perspective|-p <perspective>] [--ground|-G] [--focus|-f <section>[,...]] [--force|-F] [--next|-n <option>[,...]] [<id>]"
 description: >
     Interview the user relentlessly about the task plan until reaching a
     shared understanding, resolving each branch of the question decision
@@ -22,7 +22,7 @@ Iteratively Grill a Task Plan
 
 <expand name="getopt"
     arg1="ase-task-grill"
-    arg2="--rounds|-r=1 --next|-n=(none|DONE|EDIT|IMPLEMENT|PREFLIGHT)... --int-reuse-task">
+    arg2="--rounds|-r=1 --until|-u=(MUST|SHOULD|MAY) --perspective|-p= --ground|-G --focus|-f=(all|SPECIFICATION|SPEC|DESIGN|DES|VERIFICATION|VER)... --force|-F --next|-n=(none|DONE|GRILL|EDIT|IMPLEMENT|DRAFT)... --int-reuse-task">
     $ARGUMENTS
 </expand>
 
@@ -61,7 +61,31 @@ Set <args>--int-reuse-task</args>.
         ⧉ **ASE**: ☻ skill: **ase-task-grill**, ▶ ERROR: invalid `--rounds` value: **<getopt-option-rounds/>**
         </template>
 
-    3.  React on task id:
+    3.  Treat <getopt-option-focus/> as a comma-separated list of
+        *section tokens*. Trim and upper-case every token, then expand
+        the abbreviations `SPEC`, `DES`, and `VER` to `SPECIFICATION`,
+        `DESIGN`, and `VERIFICATION`, and expand the sentinel `ALL`
+        (the default) to `SPECIFICATION,DESIGN,VERIFICATION`. Set
+        <sections/> to the resulting list, *keeping the given order*.
+        The getopt parser validates only the *first* token, so you
+        *MUST* validate each token yourself: if any token is *empty*,
+        *not* one of the recognized sections or abbreviations, or
+        results in a section already present in <sections/>, bind
+        <token/> to that offending token, then only output the
+        following <template/> and immediately *STOP* processing the
+        entire current skill:
+
+        <template>
+        ⧉ **ASE**: ☻ skill: **ase-task-grill**, ▶ ERROR: invalid `--focus` token: **<token/>**
+        </template>
+
+        Each section in <sections/> selects its *focus areas* of the
+        grilling: `SPECIFICATION` selects `DOMAIN` and `INTERFACE`,
+        `DESIGN` selects `ARCHITECTURE` and `IMPLEMENTATION`, and
+        `VERIFICATION` selects `REGRESSION` and `CONFIRMATION`. Do not
+        output anything.
+
+    4.  React on task id:
 
         <expand name="task-react-id" arg1="ase-task-grill"></expand>
 
@@ -72,166 +96,226 @@ Set <args>--int-reuse-task</args>.
         <expand name="task-load-content"></expand>
 
     2.  <if condition="<task-content/> is empty">
-        Complain and tell the user to use the `ase-code-resolve`,
-        `ase-code-refactor`, `ase-code-craft`, or `ase-task-edit` skills
+        Complain and tell the user to use the `ase-task-edit` skill
         first to create a task plan. Then immediately stop processing
         this skill.
         </if>
 
-3.  **Iterate Over Task Plan Aspects:**
+    3.  Determine the *grilling scope* of each section in <sections/>,
+        in order to grill an *already grilled* section again *only* where
+        questions are still *open*:
 
-    1.  Understand what "grilling" is about:
-
-        <expand name="grill-understanding" arg1="the task plan in <task-content/>"></expand>
+        -   If <getopt-option-force/> is `true`, *ignore* any
+            `grilled:<section/>` tag: the scope of *every* section is the
+            *entire* section, so already grilled sections are *re-grilled*
+            completely. Skip the following two cases.
 
-    2.  Perform <getopt-option-rounds/> grilling *rounds*, numbered
-        <m/> (1-<getopt-option-rounds/>). Each round starts *from
-        scratch* from *only* the *current* <task-content/> -- as
-        updated by all previous rounds -- and *forgets* all questions
-        and answers gathered in previous rounds.
-
-        For each round:
-
-        1.  INITIALIZE ROUND:
-
-            Set <round-id/> to `GRILLING ROUND <m/>/<getopt-option-rounds/>`
-            if <getopt-option-rounds/> is greater than 1, or to
-            `GRILLING` otherwise (a single round needs no round
-            numbering). Then output only the following <template/>:
+        -   If the `Tags:` frontmatter key of <task-content/> carries
+            the tag `grilled:<section/>` (with <section/> being the
+            *lower-case* name of the section) and the section contains
+            *no* bullet-point in checkbox state `[?]`, the section is
+            *already grilled* and nothing is open: *remove* it from
+            <sections/> and only output the following <template/>:
 
             <template>
-            ⧉ **ASE**: <round-id/>: *Relentless Interviewing Until Clarity*
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **section <section/> already grilled -- skipped (use `--force` to re-grill)**
             </template>
 
-        2.  DETERMINE QUESTIONS:
+        -   If the `Tags:` frontmatter key carries the tag
+            `grilled:<section/>` and the section contains *at least one*
+            bullet-point in checkbox state `[?]`, *restrict* the scope of
+            the section to *exactly* these `[?]` bullet-points, so the
+            grilling re-asks only the *still open* questions.
 
-            Determine the essential aspects <aspect-N/> (a one- or
-            two-word-long short identifier like `Foo` or `Bar-Baz`, also
-            serving as the topic hint) and the corresponding, very brief
-            but precise decision/question <question-N/> where a shared
-            understanding is required. Each question is chosen to
-            resolve the open points related to the above understanding
-            of grilling, by focusing on the mentioned *Focus Areas* and
-            checking the mentioned *Indicators*.
-
-            For <question-N/> use the format `Shall...?` for
-            questions of focus area `DOMAIN` and `INTERFACE`, the format
-            `Should...?` for questions of focus area `ARCHITECTURE`,
-            and the format `May...?` for questions of focus area
-            `IMPLEMENTATION`.
-
-            In every <question-N/>, encode all *literal aspects*
-            -- file and directory paths, identifiers, symbols, types,
-            commands, options, configuration keys, and literal values --
-            with backticks. Do not output anything.
-
-        3.  DETERMINE CONTEXT:
-
-            For each question, determine its focus area
-            <context-N-focus/> from the mentioned *Focus Areas*.
-            <context-N-severity/>, describing how important this
-            question is.
-
-        4.  SORT QUESTIONS:
-
-            Create a decisions/questions tree for the questions,
-            capturing the dependencies between the decisions. Then
-            *sort* the questions *primarily* by descending focus area
-            order -- first all `DOMAIN`, then all `INTERFACE`, then all
-            `ARCHITECTURE`, and then all `IMPLEMENTATION` ones -- and
-            *secondarily*, within each focus area, by the decision tree
-            order, so that each decision is asked *after* the decisions
-            it depends on. Renumber <N/> according to this order,
-            starting at `1` in *every* round, independent of the
-            numbering of previous rounds. Truncate the list after a
-            maximum of 10 questions and set <n/> to the number of
-            remaining questions. Do not output anything.
-
-        5.  For each question <question-N/> in the iteration cycle <N/>,
-            *one at a time*:
-
-            1.  Output the following <template/>:
+        -   Otherwise, the scope of the section is the *entire* section.
 
-                <template>
-                <ase-tpl-bullet-signal/> ASPECT <N/>/<n/> ▶ **<context-N-focus/>** (<context-N-severity/>) ▷ **<aspect-N/>**
-                </template>
+        Independent of the scope, bullet-points in checkbox state `[-]`
+        (cancelled) or `[>]` (deferred) are *inert*: they are *never*
+        subject of a question and their checkbox is *never* changed.
 
-            2.  Determine the answer alternatives:
+        <if condition="<sections/> is empty afterwards">
+        Skip the entire step 3 below -- the plan is *neither* updated
+        *nor* saved -- and continue directly with step 4.
+        </if>
 
-                1.  Check the <task-content/> for the answer <answer-N-1/>,
-                    which reflects the current plan.
+3.  **Iterate Over Task Plan Aspects:**
 
-                2.  Check the code base and your world knowledge and
-                    use this information to find *up to three* grounded
-                    alternative answers <answer-N-K/> (K={2,3,4}), so there
-                    are between two and four answer options in total.
+    1.  Understand what "grilling" is about:
 
-                3.  For each <answer-N-K/> (K={1,2,3,4}) determine
-                    a 1-3 word label <answer-N-K-label/>, and an
-                    ultra brief description <answer-N-K-description/>
-                    of at most *10 words*. Prepend `⚑ ` to the
-                    <answer-N-K-description/> which reflects the current
-                    plan. Do not output anything.
+        <expand name="grill-understanding"
+            arg1="the task plan in <task-content/>"
+            arg2="<getopt-option-perspective/>"
+            arg3="<getopt-option-ground/>"></expand>
 
-            3.  In the following, you *MUST* *NOT* use your built-in
-                <user-dialog-tool/> tool! Instead, you *MUST* just show a
-                custom dialog according to the expanded `custom-dialog`
-                definition. You *MUST* closely follow this definition.
+        Ground the grilling:
 
-                Let the user select the <answer-N/> out of the answer
-                alternatives <answer-N-K/> by raising a question with the
-                following custom dialog. Emit only the answer lines for
-                the alternatives <answer-N-K/> you actually determined in
-                the previous step (between two and four lines in total),
-                followed by the fixed `SKIP GRILLING` answer option:
+        <expand name="grill-ground"
+            arg1="the task plan in <task-content/>"
+            arg2=""></expand>
 
-                <expand name="custom-dialog" arg1="--other">
-                    <aspect-N/>: <question-N/>
-                    <answer-N-1-label/>: <answer-N-1-description/>
-                    <answer-N-2-label/>: <answer-N-2-description/>
-                    [...]
-                    SKIP GRILLING: skip all remaining grilling and continue with the plan update
-                </expand>
+    2.  <if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">
+        Set <timestamp-created><text/></timestamp-created> (set
+        timestamp-created to extracted text).
+        </if>
 
-                Check the <result/> and dispatch accordingly:
+    3.  Perform *at most* <getopt-option-rounds/> grilling *rounds*,
+        numbered <m/> (1-<getopt-option-rounds/>) -- the round count is
+        a *maximum* only, as every round can *stop* the grilling *early*
+        in its item 2 below.
 
-                -   If <result/> is `CANCEL`, only output the following
-                    <template/> and then immediately *STOP* processing
-                    the entire current skill, leaving the plan *untouched*:
+        For each round:
 
-                    <template>
-                    ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **grilling stopped**
-                    </template>
+        1.  INITIALIZE ROUND:
 
-                -   If <result/> is `SKIP GRILLING`, ask no further
-                    questions, continue with item 6 below (updating the
-                    plan with the answers gathered so far), and after
-                    item 6 skip all remaining rounds and continue with
-                    item 3.3 below.
+            Explicitly start *from scratch* from *only* the *current*
+            <task-content/> -- as updated by all previous rounds -- and
+            *forget* all questions and answers gathered in previous
+            rounds -- except the grounding facts <grill-facts/>. Set
+            <round-id/> to
+            `GRILLING ROUND <m/>/<getopt-option-rounds/>` if
+            <getopt-option-rounds/> is greater than 1, or to
+            `GRILLING` otherwise (a single round needs no round
+            numbering). Do not output anything.
 
-                -   Otherwise, strip any leading `OTHER: ` prefix from
-                    <result/> and set <answer-N/> to the remainder.
+        2.  DETERMINE QUESTIONS:
 
-            4.  Output the following <template/>:
+            <expand name="grill-questions"
+                arg1="<getopt-option-until/>"
+                arg2="◉ task: **<ase-task-id/>**"
+                arg3="file and directory paths, identifiers, symbols, types, commands, options, configuration keys, and literal values"
+                arg4="the <task-content/>, the code base,"
+                arg5=", and *finally* by the decision tree order, which *overrides* the impact order wherever a decision has to be asked *after* the decisions it depends on">
+                Focus *only* on the *Focus Areas* selected by
+                <sections/> -- the *themes* of the focused sections,
+                *within* the *grilling scope* of each section as
+                determined in step 2.3, while the *entire*
+                <task-content/> stays the context -- and check the
+                mentioned *Indicators*. For a section restricted to its
+                `[?]` bullet-points, derive the questions from *exactly*
+                these bullet-points only. Never raise a question about a
+                `[-]` or `[>]` bullet-point. Create a decisions/questions
+                tree for the questions, capturing the dependencies
+                between the decisions.
+
+                For each question, set <items-N/> to the bullet-points of
+                <task-content/> the question is about -- possibly *none*,
+                if the question concerns an aspect the plan does not
+                cover yet.
+            </expand>
+
+            If <grill-stop/> is `true`, skip the items 3, 4, and 6 of
+            this round, perform item 5 of this round (as the focused
+            sections are clear, they are tagged as grilled), then skip
+            all remaining rounds and continue with step 4.
+
+        3.  INTERACTIVE DIALOG:
+
+            In the following, you *MUST* *NOT* use your built-in
+            <user-dialog-tool/> tool! Instead, you *MUST* just show a
+            custom dialog according to the expanded `custom-dialog`
+            definition. You *MUST* closely follow this definition. The
+            dialog below carries the fixed answer option
+            `SKIP GRILLING`, dispatched as follows:
+
+            -   If a <result/> is `SKIP GRILLING`, ask no further
+                questions -- *all* questions of this round stay
+                *unanswered* --, continue with items 4 to 6 below
+                (updating and saving the plan with the answers of the
+                previous rounds), and afterwards skip all remaining
+                rounds and continue with step 4.
+
+            -   If a <result/> is `CANCEL`, only output the following
+                <template/> and then immediately *STOP* processing the
+                entire current skill, *not* updating the plan with the
+                current round (the plan updates saved by previous
+                rounds are kept):
 
                 <template>
-                <ase-tpl-bullet-normal/> ASPECT <N/>/<n/> ▶ **<context-N-focus/>** (<context-N-severity/>) ▷ **<aspect-N/>**, ANSWER: **<answer-N/>**
+                ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **grilling stopped**
                 </template>
 
-        6.  Update <task-content/> based on all answers <answer-N/>
-            gathered in this round. Do not output anything.
+            Show a custom dialog. Its only answer option is the fixed
+            one, so the user normally answers all aspects in *one*
+            free-text reply:
+
+            <expand name="custom-dialog" arg1="--other">
+                <round-id/>: What is your (combined) answer to all (or a subset) of the above questions? (keywords or `nX` short responses are sufficient)
+                SKIP GRILLING: skip all remaining grilling and continue with the plan update
+            </expand>
+
+            Dispatch `SKIP GRILLING` and `CANCEL` as defined above.
+            Otherwise, strip any leading `OTHER: ` prefix from
+            <result/> and treat the remainder as the combined free-text
+            answers to all questions of the round.
+
+        4.  MERGE ANSWERS INTO PLAN:
+
+            Merge all gathered answers in <result/> of the round -- the
+            combined reply -- *exclusively* back into <task-content/>.
+
+            <expand name="grill-short-responses"></expand>
+
+            A question *not* addressed by the combined reply accepts its
+            answer marked with `⚑` (the current plan) if one exists, and
+            otherwise stays *unanswered*. Additionally, record the
+            *open* questions in the checkboxes of the body
+            bullet-points, changing *only* checkboxes in state `[ ]` or
+            `[?]` and leaving every `[/]`, `[x]`, `[-]`, and `[>]`
+            checkbox *untouched*:
+
+            -   For each *answered* question, set the checkbox of every
+                bullet-point in <items-N/> to `[ ]`, as the question is
+                resolved now.
+
+            -   For each *unanswered* question, set the checkbox of every
+                bullet-point in <items-N/> to `[?]`, as the question is
+                still open. If <items-N/> is *empty*, *add* a new `[?]`
+                bullet-point to the section of the question's focus area
+                <context-N-focus/>, with the corresponding <type/>, a
+                <summary/> derived from <context-N-topic/>, and a <text/>
+                stating the open <question-N-text/>, so a later grilling
+                can re-ask it.
+
+            Set <changes/> to all bullet-points of <task-content/> which
+            were changed or added in this round. Do not output anything.
+
+        5.  SAVE PLAN:
+
+            For each section in <sections/>, *set* the tag
+            `grilled:<section/>` -- with <section/> being the
+            *lower-case* name of the section (`specification`,
+            `design`, or `verification`) -- in the `Tags:` frontmatter
+            key of <task-content/>: keep an already present identical
+            tag as is, otherwise append it, keeping all other already
+            present tags (including `grilled:` tags of other sections)
+            and *creating* the whole key at its position in the key
+            order of the plan <format/> if the plan carries none. A
+            fully grilled plan hence carries the tags
+            `grilled:specification, grilled:design,
+            grilled:verification`.
+
+            <expand name="task-save-content" arg1="plan updated"></expand>
+
+        6.  SHOW PLAN CHANGES:
+
+            Set <round-suffix/> to
+            ` round <m/>/<getopt-option-rounds/>` if
+            <getopt-option-rounds/> is greater than 1, or to empty
+            otherwise, and only output the following <template/>, which
+            shows every bullet-point of <changes/> in its plan format
+            `-   <box/> <type/>: **<summary/>**: <text/>`, grouped below
+            a `**<SECTION>**:` line per plan section, where an empty
+            <changes/> renders as `(none)` -- this intentionally closes
+            *every* round, so the intermediate plan changes stay
+            visible:
 
-    3.  <if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">
-        Set <timestamp-created><text/></timestamp-created> (set
-        timestamp-created to extracted text).
-        </if>
+            <template>
+            <ase-tpl-head title="PLAN CHANGES" subtitle="after grilling<round-suffix/>"/>
 
-    4.  *Add* the value `grilled` to the `Properties:` frontmatter key of
-        <task-content/> if it is still absent, keeping all already
-        present values and *creating* the whole key (with the single
-        value `grilled`) if the plan carries none.
+            <changes/>
 
-    5.  <expand name="task-save-content" arg1="plan updated"></expand>
+            <ase-tpl-foot title="PLAN CHANGES" subtitle="after grilling<round-suffix/>"/>
+            </template>
 
 4.  **Decide Next Step:**
 
@@ -239,11 +323,12 @@ Set <args>--int-reuse-task</args>.
 
         <expand name="task-next-select"
             arg1="ase-task-grill"
-            arg2="DONE|EDIT|IMPLEMENT|PREFLIGHT">
+            arg2="DONE|GRILL|EDIT|IMPLEMENT|DRAFT">
             Next Step: How would you like to proceed with the plan?
             DONE: Stop processing.
+            GRILL: Re-grill the entire plan again.
             EDIT: Hand off plan to editing.
-            PREFLIGHT: Hand off plan to pre-flighting.
+            DRAFT: Hand off plan to implementation drafting.
             IMPLEMENT: Hand off plan to implementation.
         </expand>
 
@@ -257,6 +342,27 @@ Set <args>--int-reuse-task</args>.
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- done**
             </template>
 
+        -   If <result/> is `GRILL`:
+            <expand name="handoff-args"/>
+            Set <args><args/> --force --rounds <getopt-option-rounds/> --until <getopt-option-until/> --focus <getopt-option-focus/></args>.
+            <if condition="<getopt-option-perspective/> is not empty">
+                Set <args><args/> --perspective <getopt-option-perspective/></args>,
+                with the value shell-quoted if it contains spaces or special characters.
+            </if>
+            <if condition="<getopt-option-ground/> is `true`">
+                Set <args><args/> --ground</args>.
+            </if>
+            Only output the following <template/> and then call the
+            tool `Skill(skill: "ase:ase-task-grill", args: "<args/>")`
+            to invoke the `ase:ase-task-grill` skill again in order to
+            *re-grill* the updated plan with the same grilling options.
+            Immediately stop processing the current skill once the
+            `Skill` tool was used.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- hand-off to re-grilling**
+            </template>
+
         -   If <result/> is `EDIT`:
             <expand name="handoff-args"/>
             Only output the following <template/> and then call the
@@ -269,14 +375,15 @@ Set <args>--int-reuse-task</args>.
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- hand-off to edit**
             </template>
 
-        -   If <result/> is `PREFLIGHT`:
+        -   If <result/> is `DRAFT`:
             <expand name="handoff-args"/>
-            Only output the following <template/> and then call the
-            `Skill(skill: "ase:ase-task-preflight", args: "<args/>")` tool
-            to *apply* the plan.
+            Set <args><args/> --draft</args>. Only output the following
+            <template/> and then call the
+            `Skill(skill: "ase:ase-task-implement", args: "<args/>")` tool
+            to *draft* the implementation of the plan.
 
             <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- hand-off to pre-flight**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- hand-off to implementation draft**
             </template>
 
         -   If <result/> is `IMPLEMENT`:
@@ -288,3 +395,4 @@ Set <args>--int-reuse-task</args>.
             <template>
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- hand-off to implementation**
             </template>
+