git:20260920.ec8fb14 to git:20260928.1be72e2

---

name: ase-task-grill

argument-hint: "[--help|-h] [--rounds|-r <n>] [--until|-u MUST|SHOULD|MAY] [--focus|-f <section>[,...]] [--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

tree. Use when the user wants to stress-test a plan, get grilled on

their plan, or mentions "grill me" or "grill plan".

user-invocable: true

disable-model-invocation: false

effort: high

---

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md

@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md

@${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md

@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md

<purpose name="ase-task-grill">

Iteratively Grill a Task Plan

</purpose>

<expand name="getopt"

arg1="ase-task-grill"

arg2="--rounds|-r=1 --until|-u=(MUST|SHOULD|MAY) --focus|-f=(all|SPECIFICATION|SPEC|DESIGN|DES|VERIFICATION|VER)... --next|-n=(none|DONE|EDIT|IMPLEMENT|PREFLIGHT)... --int-reuse-task">

$ARGUMENTS

</expand>

<objective>

Interview the user relentlessly about every essential aspect of the

task plan until reaching a shared understanding.

</objective>

@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md

@${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md

@${CLAUDE_SKILL_DIR}/../../meta/ase-common-grill.md

Procedure

---------

<define name="handoff-args">

Set <args>--int-reuse-task</args>.

<if condition="<getopt-option-next/> is not equal `none`">

Set <args><args/> --next <getopt-option-next/></args>

</if>

</define>

1. **Determine Task:**

1. Set <instruction><getopt-arguments/></instruction> initially, with any

leading and trailing whitespace stripped.

Inherit the always existing <ase-task-id/> from the current context.

Inherit the always existing <ase-session-id/> from the current context.

Do not output anything.

2. If <getopt-option-rounds/> is not a positive integer,

only output the following <template/> and then immediately

*STOP* processing the entire current skill:

<template>

⧉ **ASE**: ☻ skill: **ase-task-grill**, ▶ ERROR: invalid `--rounds` value: **<getopt-option-rounds/>**

</template>

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>

2. **Determine Task Plan:**

1. Determine the current task plan content:

<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

first to create a task plan. Then immediately stop processing

this skill.

</if>

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*:

- 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**: ◉ task: **<ase-task-id/>**, ▶ status: **section <section/> already grilled -- skipped**

</template>

- 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.

- Otherwise, the scope of the section is the *entire* section.

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.

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

3. **Iterate Over Task Plan Aspects:**

1. Understand what "grilling" is about:

<expand name="grill-understanding" arg1="the task plan in <task-content/>"></expand>

numbered <m/> (1-<getopt-option-rounds/>) -- the round count is

a *maximum* only, as every round can *stop* the grilling *early*

For each round:

1. INITIALIZE ROUND:

`GRILLING` otherwise (a single round needs no round

2. DETERMINE QUESTIONS:

<template>

</template>

- 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

4. **Decide Next Step:**

1. *Determine next step*:

<expand name="task-next-select"

arg1="ase-task-grill"

arg2="DONE|EDIT|IMPLEMENT|PREFLIGHT">

Next Step: How would you like to proceed with the plan?

DONE: Stop processing.

EDIT: Hand off plan to editing.

PREFLIGHT: Hand off plan to pre-flighting.

IMPLEMENT: Hand off plan to implementation.

</expand>

2. Check the tool <result/> and dispatch accordingly:

- If <result/> is `DONE` or `CANCEL`:

Only output the following <template/> and then *STOP*,

without output of any further information.

<template>

⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- done**

</template>

- If <result/> is `EDIT`:

<expand name="handoff-args"/>

Only output the following <template/> and then call the

tool `Skill(skill: "ase:ase-task-edit", args: "<args/>")`

to invoke the `ase:ase-task-edit` skill in order to *edit*

the updated plan. Immediately stop processing the current

skill once the `Skill` tool was used.

<template>

⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- hand-off to edit**

</template>

- If <result/> is `PREFLIGHT`:

<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.

<template>

⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- hand-off to pre-flight**

</template>

- If <result/> is `IMPLEMENT`:

<expand name="handoff-args"/>

Only output the following <template/> and then call the

`Skill(skill: "ase:ase-task-implement", args: "<args/>")` tool

to *apply* the plan.

<template>

⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- hand-off to implementation**

</template>