/ase-task-dissect

name: ase-task-dissect
argument-hint: "[--help|-h] [--max-parts|-m <count>] [--dry|-d] [--force|-f] [<task-id>[:]] [<dissect-hint>]"
description: >
    Dissect the current or given task plan, treated as an epic,
    domain-wise and logically into cohesive parts and materialize each
    part as its own separate task plan. Use when the user calls to
    "dissect", "split", "break up", or "decompose" a large "task" or
    "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-getopt.md

<purpose name="ase-task-dissect"> Dissect a Task Plan </purpose>

<expand name="getopt" arg1="ase-task-dissect" arg2="--max-parts|-m=8 --dry|-d --force|-f --int-reuse-task"> $ARGUMENTS </expand>

<objective> *Dissect* a task plan, treated as an *epic*, domain-wise and logically into *cohesive parts*, and materialize every part as its own separate *task plan*. </objective>

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

<if condition=" <instruction/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*:?$` "> The lone token is the *task id* (with an optional and ignored trailing `:`), never a hint. Set <ase-task-id><instruction/></ase-task-id> (set task id to instruction, with any trailing `:` stripped) and <instruction></instruction> (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 <template/>:

<template> ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given** </template> </if>

<elseif condition=" <instruction/> has the format `<id/>: <text/>` where <id/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$` "> Set <instruction><text/></instruction> (set instruction to text) and <ase-task-id><id/></ase-task-id> (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 <template/>:

<template> ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given** </template> </elseif>

3. React on the dissection hint:

Set <dissect-hint><instruction/></dissect-hint> (set the dissection hint to the *remaining* instruction), with any leading and trailing whitespace stripped.

<if condition="<dissect-hint/> is not empty"> Only output the following <template/>:

<template> ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ hint: **<dissect-hint/>** </template> </if> <else> No dissection hint was given, so the parts are derived from the plan alone. Do not output anything. </else>

2. **Determine Operation:**

1. Determine the current task plan content:

<expand name="task-load-content"></expand>

2. If the <task-content/> 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="<dissect-hint/>" arg3="<ase-task-id/>" > the individual bullet points of the `## CHANGES` and `## VERIFICATION` sections of the loaded plan <task-content/> </expand>

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

<expand name="dissect-report" arg1="<ase-task-id/>"></expand>

4. **Materialize Sub-Task Plans:**

You *MUST* *NOT* modify, re-save, or delete the epic plan <task-content/> of <ase-task-id/> itself -- it always stays *untouched*.

1. <if condition="<getopt-option-dry/> is equal `true`"> The dissection is *reported only*, so no artifacts are created at all. Only output the following <template/> and then *SKIP* the remaining sub-steps 4.2 to 4.4 and continue with step 5:

<template> ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ dissection: **<n/>** parts, ▶ status: **dry-run -- no sub-task plans created** </template> </if>

2. *Detect target collisions*, strictly *before* writing anything:

Call the `ase_task_list(verbose: false)` tool of the `ase` MCP server and set <ex