ase-task-grill

@${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

$ARGUMENTS

@${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

1. Determine Task:

   1. Set initially, with any leading and trailing whitespace stripped. Inherit the always existing from the current context. Inherit the always existing from the current context. Do not output anything.

   2. If is not a positive integer, only output the following and then immediately STOP processing the entire current skill:

   3. React on task id:

2. Determine Task Plan:

   1. Determine the current task plan content:

3. Iterate Over Task Plan Aspects:

   1. Understand what "grilling" is about:

   2. Perform grilling rounds, numbered (1-). Each round starts from scratch from only the current -- as updated by all previous rounds -- and forgets all questions and answers gathered in previous rounds.

      For each round:

      1. INITIALIZE ROUND:

         Set to GRILLING ROUND <m/>/<getopt-option-rounds/> if is greater than 1, or to GRILLING otherwise (a single round needs no round numbering). Then output only the following :

      2. DETERMINE QUESTIONS:

         Determine the essential aspects (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 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 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 , 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 from the mentioned Focus Areas. , 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 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 to the number of remaining questions. Do not output anything.

      5. For each question in the iteration cycle , one at a time:

         1. Output the following :

         2. Determine the answer alternatives:

            1. Check the for the answer , which reflects the current plan.

            2. Check the code base and your world knowledge and use this information to find up to three grounded alternative answers (K={2,3,4}), so there are between two and four answer options in total.

            3. For each (K={1,2,3,4}) determine a 1-3 word label , and an ultra brief description of at most 10 words. Prepend ⚑ to the which reflects the current plan. Do not output anything.

         3. In the following, you MUST NOT use your built-in tool! Instead, you MUST just show a custom dialog according to the expanded custom-dialog definition. You MUST closely follow this definition.

            Let the user select the out of the answer alternatives by raising a question with the following custom dialog. Emit only the answer lines for the alternatives you actually determined in the previous step (between two and four lines in total), followed by the fixed SKIP GRILLING answer option:

            Check the and dispatch accordingly:

            • If is CANCEL, only output the following and then immediately STOP processing the entire current skill, leaving the plan untouched:

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

            • Otherwise, strip any leading OTHER: prefix from and set to the remainder.

         4. Output the following :

      6. Update based on all answers gathered in this round. Do not output anything.

   4. Add the value grilled to the Properties: frontmatter key of 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.

4. Decide Next Step:

   1. Determine next step:

      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.

   2. Check the tool and dispatch accordingly:

      • If is DONE or CANCEL: Only output the following and then STOP, without output of any further information.

      • If is EDIT: Only output the following 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.

      • If is PREFLIGHT: Only output the following and then call the Skill(skill: "ase:ase-task-preflight", args: "<args/>") tool to apply the plan.

      • If is IMPLEMENT: Only output the following and then call the Skill(skill: "ase:ase-task-implement", args: "<args/>") tool to apply the plan.