Ase Task Dissect

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.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-dissect.md

Procedure

1. Determine Task and Hint:

   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. React on the task id:

      The lone token is the task id (with an optional and ignored trailing :), never a hint. Set (set task id to instruction, with any trailing : stripped) and (set instruction empty), call the ase_task_id(id: "<ase-task-id/>", session: "<ase-session-id/>") tool from the ase MCP server to switch the task, and then only output the following :

      Set (set instruction to text) and (set task id to id), call the ase_task_id(id: "<ase-task-id/>", session: "<ase-session-id/>") tool from the ase MCP server to switch the task, and then only output the following :

   3. React on the dissection hint:

      Set (set the dissection hint to the remaining instruction), with any leading and trailing whitespace stripped.

2. Determine Operation:

   1. Determine the current task plan content:

   2. If the is still 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.

3. Dissect Task Plan:

   1. Derive the parts of the epic:

      <expand name="dissect-derive" arg1="ase-task-dissect" arg2="" arg3=""

      the individual bullet points of the ## CHANGES and ## VERIFICATION sections of the loaded plan

      Each ## VERIFICATION bullet point MUST land in the very part which carries the ## CHANGES bullet points it verifies.

      A single bullet point is not the smallest unit here: a bullet point which itself covers multiple domains or concerns MAY be split per rule 3 into two or more bullet point fragments, each of which is a complete bullet point of its own, is formed exclusively from the wording of the original bullet point, and is then assigned to a part like an ordinary bullet point. A split ## VERIFICATION bullet point follows the ## CHANGES bullet points its fragments verify, so its fragments MAY land in different parts.

   2. Report the parts:

4. Materialize Sub-Task Plans:

   You MUST NOT modify, re-save, or delete the epic plan of itself -- it always stays untouched.

   2. Detect target collisions, strictly before writing anything:

      Call the ase_task_list(verbose: false) tool of the ase MCP server and set to the id fields of the returned tasks array. Do not output anything related to this MCP tool call. Set to all of which are already present in .

      Directly after this , and before stopping, give the corrective hint by expanding the following (which, depending on the configured , may expand into nothing and hence emit no output at all):

   3. Compose and persist one sub-task plan per part:

      Call the ase_timestamp(format: "yyyy-LL-dd HH:mm") tool of the ase MCP server once and use the text field of its response for both the and information of all parts.

      Then, for every part in , in their derived order:

      1. Compose a complete task plan by closely following the plan , where:

         • the is ,
         • the is derived from the part's ,
         • the ## CONTEXT section carries a part-local and , derived from the part's own input elements plus the ## CONTEXT section of the epic,
         • the ## CHANGES section carries exactly the ## CHANGES bullet points assigned to this part, keeping their original wording, and
         • the ## VERIFICATION section carries exactly the ## VERIFICATION bullet points assigned to this part, keeping their original wording.

         For a bullet point which was split into fragments, the part carries only its own fragment: the keeps the original wording of the portion this fragment covers, with no re-interpretation and no added scope, and the **<aspect/>** label is narrowed to exactly that portion. Across all parts, the fragments of a split bullet point MUST still reproduce the original bullet point completely and without duplication.

         The loaded is the rendering-prepared variant of the epic, so it carries artifacts which MUST NOT leak into the persisted . While copying, you MUST normalize every taken-over bullet point back into the authoring form of the plan :

         • Restore the bullet markers: a bullet point rendered as ◯ is written back as - -- MUST NOT contain a single ◯ marker.

         • Re-join split code spans: an inline code span which the rendering split across two physical lines into two spans (`<head/>` at a line end and `<tail/>` at the next line start) is written back as the one original span `<head/> <tail/>`, and the line is then broken before its opening backtick, per the line-breaking rules of the plan .

      2. Call the ase_task_save(id: "<part-id/>", text: "<part-content/>") tool of the ase MCP server to persist the sub-task plan, and calculate the number of words of . Do not output anything related to this MCP tool call except the following :

   4. Report the overall result with the following :

5. Give Final Hints:

   Finally, give the closing hints by expanding the following (which, depending on the configured , may each expand into nothing and hence emit no output at all):